[svn] / branches / dev-api-4 / xvidcore / vfw / src / codec.c Repository:
ViewVC logotype

Annotation of /branches/dev-api-4/xvidcore/vfw/src/codec.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1193 - (view) (download)

1 : suxen_drol 889 /**************************************************************************
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 : suxen_drol 1017 #include "vfwext.h"
53 : suxen_drol 889
54 : suxen_drol 983 #include <xvid.h>
55 :     #include "debug.h"
56 : suxen_drol 889 #include "codec.h"
57 : suxen_drol 1061 #include "status.h"
58 : suxen_drol 889
59 : suxen_drol 983
60 :     static const int pmvfast_presets[7] = {
61 : suxen_drol 889 0, 0, 0, 0,
62 : edgomez 949 0 | XVID_ME_HALFPELREFINE16 | 0,
63 :     0 | XVID_ME_HALFPELREFINE16 | 0 |
64 :     XVID_ME_ADVANCEDDIAMOND16, XVID_ME_HALFPELREFINE16 | XVID_ME_EXTSEARCH16 |
65 :     XVID_ME_HALFPELREFINE8 | 0 | XVID_ME_USESQUARES16
66 : suxen_drol 889 };
67 :    
68 : suxen_drol 983
69 :    
70 : suxen_drol 889 /* return xvid compatbile colorspace,
71 :     or XVID_CSP_NULL if failure
72 :     */
73 :    
74 :     int get_colorspace(BITMAPINFOHEADER * hdr)
75 :     {
76 :     /* rgb only: negative height specifies top down image */
77 :     int rgb_flip = (hdr->biHeight < 0 ? 0 : XVID_CSP_VFLIP);
78 :    
79 :     switch(hdr->biCompression)
80 :     {
81 :     case BI_RGB :
82 :     if (hdr->biBitCount == 16)
83 :     {
84 : suxen_drol 983 DPRINTF("RGB16 (RGB555)");
85 : suxen_drol 889 return rgb_flip | XVID_CSP_RGB555;
86 :     }
87 :     if (hdr->biBitCount == 24)
88 :     {
89 : suxen_drol 983 DPRINTF("RGB24");
90 : suxen_drol 889 return rgb_flip | XVID_CSP_BGR;
91 :     }
92 :     if (hdr->biBitCount == 32)
93 :     {
94 : suxen_drol 983 DPRINTF("RGB32");
95 : suxen_drol 889 return rgb_flip | XVID_CSP_BGRA;
96 :     }
97 :    
98 : suxen_drol 983 DPRINTF("unsupported BI_RGB biBitCount=%i", hdr->biBitCount);
99 : suxen_drol 889 return XVID_CSP_NULL;
100 :    
101 :     case BI_BITFIELDS :
102 :     if (hdr->biSize >= sizeof(BITMAPV4HEADER))
103 :     {
104 :     BITMAPV4HEADER * hdr4 = (BITMAPV4HEADER *)hdr;
105 :    
106 :     if (hdr4->bV4BitCount == 16 &&
107 :     hdr4->bV4RedMask == 0x7c00 &&
108 :     hdr4->bV4GreenMask == 0x3e0 &&
109 :     hdr4->bV4BlueMask == 0x1f)
110 :     {
111 : suxen_drol 983 DPRINTF("RGB555");
112 : suxen_drol 889 return rgb_flip | XVID_CSP_RGB555;
113 :     }
114 :    
115 :     if(hdr4->bV4BitCount == 16 &&
116 :     hdr4->bV4RedMask == 0xf800 &&
117 :     hdr4->bV4GreenMask == 0x7e0 &&
118 :     hdr4->bV4BlueMask == 0x1f)
119 :     {
120 : suxen_drol 983 DPRINTF("RGB565");
121 : suxen_drol 889 return rgb_flip | XVID_CSP_RGB565;
122 :     }
123 :    
124 : suxen_drol 983 DPRINTF("unsupported BI_BITFIELDS mode");
125 : suxen_drol 889 return XVID_CSP_NULL;
126 :     }
127 :    
128 : suxen_drol 983 DPRINTF("unsupported BI_BITFIELDS/BITMAPHEADER combination");
129 : suxen_drol 889 return XVID_CSP_NULL;
130 :    
131 :     case FOURCC_I420 :
132 :     case FOURCC_IYUV :
133 : suxen_drol 983 DPRINTF("IYUY");
134 : suxen_drol 889 return XVID_CSP_I420;
135 :    
136 :     case FOURCC_YV12 :
137 : suxen_drol 983 DPRINTF("YV12");
138 : suxen_drol 889 return XVID_CSP_YV12;
139 :    
140 :     case FOURCC_YUYV :
141 :     case FOURCC_YUY2 :
142 : suxen_drol 983 DPRINTF("YUY2");
143 : suxen_drol 889 return XVID_CSP_YUY2;
144 :    
145 :     case FOURCC_YVYU :
146 : suxen_drol 983 DPRINTF("YVYU");
147 : suxen_drol 889 return XVID_CSP_YVYU;
148 :    
149 :     case FOURCC_UYVY :
150 : suxen_drol 983 DPRINTF("UYVY");
151 : suxen_drol 889 return XVID_CSP_UYVY;
152 :    
153 :     default :
154 : suxen_drol 983 DPRINTF("unsupported colorspace %c%c%c%c",
155 :     hdr->biCompression&0xff,
156 :     (hdr->biCompression>>8)&0xff,
157 :     (hdr->biCompression>>16)&0xff,
158 :     (hdr->biCompression>>24)&0xff);
159 : suxen_drol 889 return XVID_CSP_NULL;
160 :     }
161 :     }
162 :    
163 :    
164 :     /* compressor */
165 :    
166 :    
167 :     /* test the output format */
168 :    
169 :     LRESULT compress_query(CODEC * codec, BITMAPINFO * lpbiInput, BITMAPINFO * lpbiOutput)
170 :     {
171 :     BITMAPINFOHEADER * inhdr = &lpbiInput->bmiHeader;
172 :     BITMAPINFOHEADER * outhdr = &lpbiOutput->bmiHeader;
173 :    
174 : suxen_drol 1017 /* VFWEXT detection */
175 :     if (inhdr->biCompression == VFWEXT_FOURCC) {
176 :     return (ICM_USER+0x0fff);
177 :     }
178 :    
179 : suxen_drol 889 if (get_colorspace(inhdr) == XVID_CSP_NULL)
180 :     {
181 :     return ICERR_BADFORMAT;
182 :     }
183 :    
184 :     if (lpbiOutput == NULL)
185 :     {
186 :     return ICERR_OK;
187 :     }
188 :    
189 :     if (inhdr->biWidth != outhdr->biWidth || inhdr->biHeight != outhdr->biHeight ||
190 :     (outhdr->biCompression != FOURCC_XVID && outhdr->biCompression != FOURCC_DIVX && outhdr->biCompression != FOURCC_DX50))
191 :     {
192 :     return ICERR_BADFORMAT;
193 :     }
194 :    
195 :     return ICERR_OK;
196 :     }
197 :    
198 :    
199 :     LRESULT compress_get_format(CODEC * codec, BITMAPINFO * lpbiInput, BITMAPINFO * lpbiOutput)
200 :     {
201 :     BITMAPINFOHEADER * inhdr = &lpbiInput->bmiHeader;
202 :     BITMAPINFOHEADER * outhdr = &lpbiOutput->bmiHeader;
203 :    
204 :     if (get_colorspace(inhdr) == XVID_CSP_NULL)
205 :     {
206 :     return ICERR_BADFORMAT;
207 :     }
208 :    
209 :     if (lpbiOutput == NULL)
210 :     {
211 : syskin 1091 return sizeof(BITMAPINFOHEADER);
212 : suxen_drol 889 }
213 :    
214 :     memcpy(outhdr, inhdr, sizeof(BITMAPINFOHEADER));
215 :     outhdr->biSize = sizeof(BITMAPINFOHEADER);
216 :     outhdr->biSizeImage = compress_get_size(codec, lpbiInput, lpbiOutput);
217 :     outhdr->biXPelsPerMeter = 0;
218 :     outhdr->biYPelsPerMeter = 0;
219 :     outhdr->biClrUsed = 0;
220 :     outhdr->biClrImportant = 0;
221 :    
222 :     if (codec->config.fourcc_used == 0)
223 :     {
224 :     outhdr->biCompression = FOURCC_XVID;
225 :     }
226 :     else if (codec->config.fourcc_used == 1)
227 :     {
228 :     outhdr->biCompression = FOURCC_DIVX;
229 :     }
230 :     else
231 :     {
232 :     outhdr->biCompression = FOURCC_DX50;
233 :     }
234 :    
235 :     return ICERR_OK;
236 :     }
237 :    
238 :    
239 :     LRESULT compress_get_size(CODEC * codec, BITMAPINFO * lpbiInput, BITMAPINFO * lpbiOutput)
240 :     {
241 :     return 2 * lpbiOutput->bmiHeader.biWidth * lpbiOutput->bmiHeader.biHeight * 3;
242 :     }
243 :    
244 :    
245 :     LRESULT compress_frames_info(CODEC * codec, ICCOMPRESSFRAMES * icf)
246 :     {
247 : edgomez 1053 #if 0
248 :     DPRINTF("%i %i", icf->lStartFrame, icf->lFrameCount);
249 :     #endif
250 : suxen_drol 889 codec->fincr = icf->dwScale;
251 :     codec->fbase = icf->dwRate;
252 :     return ICERR_OK;
253 :     }
254 :    
255 :    
256 : suxen_drol 983 const char type2char(int type)
257 :     {
258 :     if (type==XVID_TYPE_IVOP)
259 :     return 'I';
260 :     if (type==XVID_TYPE_PVOP)
261 :     return 'P';
262 :     if (type==XVID_TYPE_BVOP)
263 :     return 'B';
264 :     return 'S';
265 :     }
266 :    
267 :     int vfw_debug(void *handle,
268 :     int opt,
269 :     void *param1,
270 :     void *param2)
271 :     {
272 :     switch (opt) {
273 :     case XVID_PLG_INFO:
274 :     case XVID_PLG_CREATE:
275 :     case XVID_PLG_DESTROY:
276 :     case XVID_PLG_BEFORE:
277 :     return 0;
278 :    
279 :     case XVID_PLG_AFTER:
280 :     {
281 :     xvid_plg_data_t *data = (xvid_plg_data_t *) param1;
282 :    
283 :     DPRINTF("[%5i] type=%c Q:%2i length:%6i",
284 :     data->frame_num,
285 :     type2char(data->type),
286 :     data->quant,
287 :     data->length);
288 :     return 0;
289 :     }
290 :     }
291 :    
292 :     return XVID_ERR_FAIL;
293 :     }
294 :    
295 :    
296 :    
297 : suxen_drol 889 LRESULT compress_begin(CODEC * codec, BITMAPINFO * lpbiInput, BITMAPINFO * lpbiOutput)
298 :     {
299 :     xvid_gbl_init_t init;
300 :     xvid_enc_create_t create;
301 : suxen_drol 983 xvid_enc_plugin_t plugins[3];
302 : suxen_drol 1017 xvid_plugin_single_t single;
303 : suxen_drol 983 xvid_plugin_2pass1_t pass1;
304 :     xvid_plugin_2pass2_t pass2;
305 : suxen_drol 1017 int i;
306 : suxen_drol 889
307 : suxen_drol 983 /* destroy previously created codec */
308 :     if(codec->ehandle) {
309 :     xvid_encore(codec->ehandle, XVID_ENC_DESTROY, NULL, NULL);
310 :     codec->ehandle = NULL;
311 :     }
312 :    
313 :     memset(&init, 0, sizeof(init));
314 :     init.version = XVID_VERSION;
315 :     init.cpu_flags = codec->config.cpu;
316 : suxen_drol 1032 init.debug = codec->config.debug;
317 : suxen_drol 983 xvid_global(0, XVID_GBL_INIT, &init, NULL);
318 :    
319 :     memset(&create, 0, sizeof(create));
320 :     create.version = XVID_VERSION;
321 : suxen_drol 1017
322 : edgomez 1053 /* zones */
323 : suxen_drol 1017 create.zones = malloc(sizeof(xvid_enc_zone_t) * codec->config.num_zones);
324 :     create.num_zones = codec->config.num_zones;
325 :     for (i=0; i < create.num_zones; i++) {
326 :     create.zones[i].frame = codec->config.zones[i].frame;
327 : suxen_drol 1032 if (codec->config.zones[i].mode == RC_ZONE_QUANT) {
328 : suxen_drol 1017 create.zones[i].mode = XVID_ZONE_QUANT;
329 :     create.zones[i].increment = codec->config.zones[i].quant;
330 :     }else{
331 :     create.zones[i].mode = XVID_ZONE_WEIGHT;
332 :     create.zones[i].increment = codec->config.zones[i].weight;
333 :     }
334 :     create.zones[i].base = 100;
335 :     }
336 :    
337 : edgomez 1053 /* plugins */
338 : suxen_drol 983 create.plugins = plugins;
339 : suxen_drol 889 switch (codec->config.mode)
340 :     {
341 : suxen_drol 1017 case RC_MODE_1PASS :
342 :     memset(&single, 0, sizeof(single));
343 :     single.version = XVID_VERSION;
344 : suxen_drol 1032 single.bitrate = codec->config.bitrate * CONFIG_KBPS;
345 : suxen_drol 1017 single.reaction_delay_factor = codec->config.rc_reaction_delay_factor;
346 :     single.averaging_period = codec->config.rc_averaging_period;
347 :     single.buffer = codec->config.rc_buffer;
348 :     plugins[create.num_plugins].func = xvid_plugin_single;
349 :     plugins[create.num_plugins].param = &single;
350 : suxen_drol 983 create.num_plugins++;
351 : suxen_drol 1032 break;
352 : suxen_drol 889
353 : suxen_drol 983 case RC_MODE_2PASS1 :
354 :     memset(&pass1, 0, sizeof(pass1));
355 :     pass1.version = XVID_VERSION;
356 : suxen_drol 1028 pass1.filename = codec->config.stats;
357 : suxen_drol 983
358 :     plugins[create.num_plugins].func = xvid_plugin_2pass1;
359 :     plugins[create.num_plugins].param = &pass1;
360 :     create.num_plugins++;
361 : suxen_drol 889 break;
362 :    
363 : suxen_drol 1017 case RC_MODE_2PASS2 :
364 : suxen_drol 983 memset(&pass2, 0, sizeof(pass2));
365 :     pass2.version = XVID_VERSION;
366 : suxen_drol 1061 if (codec->config.use_2pass_bitrate) {
367 :     pass2.bitrate = codec->config.bitrate * CONFIG_KBPS;
368 :     }else{
369 :     pass2.bitrate = -codec->config.desired_size; /* kilobytes */
370 :     }
371 : suxen_drol 983 pass2.filename = codec->config.stats;
372 : suxen_drol 1017
373 : suxen_drol 1052 pass2.keyframe_boost = codec->config.keyframe_boost; /* keyframe boost percentage: [0..100...]; */
374 :     pass2.payback_method = codec->config.bitrate_payback_method;
375 :     pass2.bitrate_payback_delay = codec->config.bitrate_payback_delay;
376 :     pass2.curve_compression_high = codec->config.curve_compression_high;
377 :     pass2.curve_compression_low = codec->config.curve_compression_low;
378 :     pass2.max_overflow_improvement = codec->config.twopass_max_overflow_improvement;
379 :     pass2.max_overflow_degradation = codec->config.twopass_max_overflow_degradation;
380 :     pass2.kftreshold = codec->config.kftreshold;
381 :     pass2.kfreduction = codec->config.kfreduction;
382 :     pass2.min_key_interval = codec->config.min_key_interval;
383 :     pass2.container_frame_overhead = 24; /* AVI */
384 :    
385 : suxen_drol 983 plugins[create.num_plugins].func = xvid_plugin_2pass2;
386 :     plugins[create.num_plugins].param = &pass2;
387 :     create.num_plugins++;
388 : suxen_drol 889 break;
389 :    
390 : suxen_drol 983 case RC_MODE_NULL :
391 : suxen_drol 889 return ICERR_OK;
392 :    
393 :     default :
394 :     break;
395 :     }
396 :    
397 : suxen_drol 1017 if ((profiles[codec->config.profile].flags & PROFILE_ADAPTQUANT) && codec->config.lum_masking) {
398 : suxen_drol 983 plugins[create.num_plugins].func = xvid_plugin_lumimasking;
399 :     plugins[create.num_plugins].param = NULL;
400 :     create.num_plugins++;
401 : suxen_drol 889 }
402 :    
403 : suxen_drol 983 plugins[create.num_plugins].func = vfw_debug;
404 :     plugins[create.num_plugins].param = NULL;
405 :     create.num_plugins++;
406 : suxen_drol 889
407 : suxen_drol 1017 create.profile = profiles[codec->config.profile].id;
408 :    
409 : suxen_drol 889 create.width = lpbiInput->bmiHeader.biWidth;
410 :     create.height = lpbiInput->bmiHeader.biHeight;
411 :     create.fincr = codec->fincr;
412 :     create.fbase = codec->fbase;
413 :    
414 :     create.max_key_interval = codec->config.max_key_interval;
415 :    
416 : suxen_drol 1017 create.min_quant[0] = codec->config.min_iquant;
417 :     create.max_quant[0] = codec->config.max_iquant;
418 :     create.min_quant[1] = codec->config.min_pquant;
419 :     create.max_quant[1] = codec->config.max_pquant;
420 :     create.min_quant[2] = codec->config.min_bquant;
421 :     create.max_quant[2] = codec->config.max_bquant;
422 :    
423 :     if ((profiles[codec->config.profile].flags & PROFILE_BVOP) && codec->config.use_bvop) {
424 : suxen_drol 983 create.max_bframes = codec->config.max_bframes;
425 : suxen_drol 1017 create.bquant_ratio = codec->config.bquant_ratio;
426 :     create.bquant_offset = codec->config.bquant_offset;
427 :    
428 :     if (codec->config.packed)
429 :     create.global |= XVID_GLOBAL_PACKED;
430 :    
431 :     if (codec->config.closed_gov)
432 :     create.global |= XVID_GLOBAL_CLOSED_GOP;
433 :    
434 :     }
435 :    
436 : suxen_drol 889 create.frame_drop_ratio = codec->config.frame_drop_ratio;
437 :    
438 : suxen_drol 1017 create.num_threads = codec->config.num_threads;
439 : suxen_drol 889
440 : suxen_drol 983 switch(xvid_encore(0, XVID_ENC_CREATE, &create, NULL))
441 : suxen_drol 889 {
442 :     case XVID_ERR_FAIL :
443 :     return ICERR_ERROR;
444 :    
445 :     case XVID_ERR_MEMORY :
446 :     return ICERR_MEMORY;
447 :    
448 :     case XVID_ERR_FORMAT :
449 :     return ICERR_BADFORMAT;
450 :    
451 :     case XVID_ERR_VERSION :
452 :     return ICERR_UNSUPPORTED;
453 :     }
454 :    
455 :     codec->ehandle = create.handle;
456 :     codec->framenum = 0;
457 :     codec->keyspacing = 0;
458 :    
459 : suxen_drol 1061 if (codec->config.display_status) {
460 :     status_destroy_always(&codec->status);
461 :     status_create(&codec->status, codec->fincr, codec->fbase);
462 :     }
463 :    
464 : suxen_drol 889 return ICERR_OK;
465 :     }
466 :    
467 :    
468 :     LRESULT compress_end(CODEC * codec)
469 :     {
470 : suxen_drol 1061 if (codec->ehandle != NULL) {
471 : suxen_drol 889 xvid_encore(codec->ehandle, XVID_ENC_DESTROY, NULL, NULL);
472 :     codec->ehandle = NULL;
473 :     }
474 :    
475 : suxen_drol 1061 if (codec->config.display_status)
476 :     status_destroy(&codec->status);
477 :    
478 : suxen_drol 889 return ICERR_OK;
479 :     }
480 :    
481 : suxen_drol 1017
482 :     static void apply_zone_modifiers(xvid_enc_frame_t * frame, CONFIG * config, int framenum)
483 :     {
484 :     int i;
485 :    
486 :     for (i=0; i<config->num_zones && config->zones[i].frame <= framenum; i++) ;
487 :     i--;
488 :    
489 : suxen_drol 1069 frame->type = config->zones[i].type;
490 :    
491 : suxen_drol 1017 if (config->zones[i].greyscale) {
492 :     frame->vop_flags |= XVID_VOP_GREYSCALE;
493 :     }
494 :    
495 :     if (config->zones[i].chroma_opt) {
496 :     frame->vop_flags |= XVID_VOP_CHROMAOPT;
497 :     }
498 :    
499 :     if ((profiles[config->profile].flags & PROFILE_BVOP) && config->use_bvop) {
500 :     frame->bframe_threshold = config->zones[i].bvop_threshold;
501 :     }
502 :     }
503 :    
504 :    
505 : suxen_drol 889 LRESULT compress(CODEC * codec, ICCOMPRESS * icc)
506 :     {
507 :     BITMAPINFOHEADER * inhdr = icc->lpbiInput;
508 :     BITMAPINFOHEADER * outhdr = icc->lpbiOutput;
509 :     xvid_enc_frame_t frame;
510 :     xvid_enc_stats_t stats;
511 :     int length;
512 :    
513 :     memset(&frame, 0, sizeof(frame));
514 :     frame.version = XVID_VERSION;
515 :    
516 :     frame.type = XVID_TYPE_AUTO;
517 :    
518 :     /* vol stuff */
519 :    
520 : suxen_drol 1017 if ((profiles[codec->config.profile].flags & PROFILE_MPEGQUANT) &&
521 :     codec->config.quant_type != QUANT_MODE_H263)
522 : suxen_drol 889 {
523 : edgomez 949 frame.vol_flags |= XVID_VOL_MPEGQUANT;
524 : suxen_drol 889
525 : suxen_drol 1017 if (codec->config.quant_type == QUANT_MODE_CUSTOM) {
526 : suxen_drol 889 frame.quant_intra_matrix = codec->config.qmatrix_intra;
527 :     frame.quant_inter_matrix = codec->config.qmatrix_inter;
528 : suxen_drol 1017 }else{
529 : suxen_drol 889 frame.quant_intra_matrix = NULL;
530 :     frame.quant_inter_matrix = NULL;
531 :     }
532 :     }
533 :    
534 : syskin 1087 if ((profiles[codec->config.profile].flags & PROFILE_REDUCED) &&
535 : suxen_drol 1017 codec->config.reduced_resolution) {
536 : edgomez 949 frame.vol_flags |= XVID_VOL_REDUCED_ENABLE;
537 :     frame.vop_flags |= XVID_VOP_REDUCED; /* XXX: need auto decion mode */
538 : suxen_drol 889 }
539 :    
540 : suxen_drol 1017 if ((profiles[codec->config.profile].flags & PROFILE_QPEL) && codec->config.qpel) {
541 : edgomez 949 frame.vol_flags |= XVID_VOL_QUARTERPEL;
542 :     frame.motion |= XVID_ME_QUARTERPELREFINE16 | XVID_ME_QUARTERPELREFINE8;
543 : suxen_drol 889 }
544 :    
545 : syskin 1087 if ((profiles[codec->config.profile].flags & PROFILE_GMC) && codec->config.gmc) {
546 : edgomez 949 frame.vol_flags |= XVID_VOL_GMC;
547 : edgomez 1107 frame.motion |= XVID_ME_GME_REFINE;
548 : syskin 1087 }
549 : suxen_drol 889
550 : suxen_drol 1017 if ((profiles[codec->config.profile].flags & PROFILE_INTERLACE) && codec->config.interlacing)
551 : edgomez 949 frame.vol_flags |= XVID_VOL_INTERLACING;
552 : suxen_drol 889
553 :     /* vop stuff */
554 :    
555 : edgomez 949 frame.vop_flags |= XVID_VOP_HALFPEL;
556 :     frame.vop_flags |= XVID_VOP_HQACPRED;
557 : suxen_drol 889
558 : suxen_drol 1032 if (codec->config.vop_debug)
559 : edgomez 949 frame.vop_flags |= XVID_VOP_DEBUG;
560 : suxen_drol 889
561 : suxen_drol 1017 if (codec->config.trellis_quant) {
562 :     frame.vop_flags |= XVID_VOP_TRELLISQUANT;
563 :     }
564 :    
565 :     if (codec->config.motion_search > 4)
566 : edgomez 949 frame.vop_flags |= XVID_VOP_INTER4V;
567 : suxen_drol 889
568 :     if (codec->config.chromame)
569 : edgomez 1107 frame.motion |= XVID_ME_CHROMA_PVOP + XVID_ME_CHROMA_BVOP;
570 : suxen_drol 889
571 : edgomez 1193 if (codec->config.cartoon_mode) {
572 :     frame.vop_flags |= XVID_VOP_CARTOON;
573 :     #if 0 /* Seems to cause crashes with P4 cpus */
574 :     frame.motion |= XVID_ME_DETECT_STATIC_MOTION;
575 :     #endif
576 :     }
577 :    
578 : suxen_drol 889 frame.motion |= pmvfast_presets[codec->config.motion_search];
579 :    
580 :     switch (codec->config.vhq_mode)
581 :     {
582 :     case VHQ_MODE_DECISION :
583 : edgomez 1107 frame.vop_flags |= XVID_VOP_MODEDECISION_RD;
584 : suxen_drol 889 break;
585 :    
586 :     case VHQ_LIMITED_SEARCH :
587 : edgomez 1107 frame.vop_flags |= XVID_VOP_MODEDECISION_RD;
588 :     frame.motion |= XVID_ME_HALFPELREFINE16_RD;
589 :     frame.motion |= XVID_ME_QUARTERPELREFINE16_RD;
590 : suxen_drol 889 break;
591 :    
592 :     case VHQ_MEDIUM_SEARCH :
593 : edgomez 1107 frame.vop_flags |= XVID_VOP_MODEDECISION_RD;
594 :     frame.motion |= XVID_ME_HALFPELREFINE16_RD;
595 :     frame.motion |= XVID_ME_HALFPELREFINE8_RD;
596 :     frame.motion |= XVID_ME_QUARTERPELREFINE16_RD;
597 :     frame.motion |= XVID_ME_QUARTERPELREFINE8_RD;
598 :     frame.motion |= XVID_ME_CHECKPREDICTION_RD;
599 : suxen_drol 889 break;
600 :    
601 :     case VHQ_WIDE_SEARCH :
602 : edgomez 1107 frame.vop_flags |= XVID_VOP_MODEDECISION_RD;
603 :     frame.motion |= XVID_ME_HALFPELREFINE16_RD;
604 :     frame.motion |= XVID_ME_HALFPELREFINE8_RD;
605 :     frame.motion |= XVID_ME_QUARTERPELREFINE16_RD;
606 :     frame.motion |= XVID_ME_QUARTERPELREFINE8_RD;
607 :     frame.motion |= XVID_ME_CHECKPREDICTION_RD;
608 :     frame.motion |= XVID_ME_EXTSEARCH_RD;
609 : suxen_drol 889 break;
610 :    
611 :     default :
612 :     break;
613 :     }
614 :    
615 :     frame.input.plane[0] = icc->lpInput;
616 :     frame.input.stride[0] = (((icc->lpbiInput->biWidth * icc->lpbiInput->biBitCount) + 31) & ~31) >> 3;
617 :    
618 :     if ((frame.input.csp = get_colorspace(inhdr)) == XVID_CSP_NULL)
619 :     return ICERR_BADFORMAT;
620 :    
621 :     if (frame.input.csp == XVID_CSP_I420 || frame.input.csp == XVID_CSP_YV12)
622 :     frame.input.stride[0] = (frame.input.stride[0]*2)/3;
623 :    
624 :     frame.bitstream = icc->lpOutput;
625 :     frame.length = icc->lpbiOutput->biSizeImage;
626 :    
627 : suxen_drol 1017 frame.quant = 0;
628 : suxen_drol 889
629 : suxen_drol 1017 if (codec->config.mode == RC_MODE_NULL) {
630 : suxen_drol 889 outhdr->biSizeImage = 0;
631 :     *icc->lpdwFlags = AVIIF_KEYFRAME;
632 :     return ICERR_OK;
633 : suxen_drol 1017 }
634 : suxen_drol 889
635 :     // force keyframe spacing in 2-pass 1st pass
636 :     if (codec->config.motion_search == 0)
637 :     {
638 :     frame.type = XVID_TYPE_IVOP;
639 :     }
640 :     else if (codec->keyspacing < codec->config.min_key_interval && codec->framenum)
641 :     {
642 : suxen_drol 983 DPRINTF("current frame forced to p-frame");
643 : suxen_drol 889 frame.type = XVID_TYPE_PVOP;
644 :     }
645 :    
646 : suxen_drol 1017 /* frame-based stuff */
647 :     apply_zone_modifiers(&frame, &codec->config, codec->framenum);
648 :    
649 :     /* call encore */
650 :    
651 : suxen_drol 889 memset(&stats, 0, sizeof(stats));
652 :     stats.version = XVID_VERSION;
653 :    
654 :     length = xvid_encore(codec->ehandle, XVID_ENC_ENCODE, &frame, &stats);
655 :     switch (length)
656 :     {
657 :     case XVID_ERR_FAIL :
658 :     return ICERR_ERROR;
659 :    
660 :     case XVID_ERR_MEMORY :
661 :     return ICERR_MEMORY;
662 :    
663 :     case XVID_ERR_FORMAT :
664 :     return ICERR_BADFORMAT;
665 :    
666 :     case XVID_ERR_VERSION :
667 :     return ICERR_UNSUPPORTED;
668 :     }
669 :    
670 : suxen_drol 1061 if (codec->config.display_status && stats.type>0) {
671 :     status_update(&codec->status, stats.type, stats.length, stats.quant);
672 :     }
673 :    
674 : suxen_drol 983 DPRINTF("{type=%i len=%i} length=%i", stats.type, stats.length, length);
675 : suxen_drol 889
676 :     if (length == 0) /* no encoder output */
677 :     {
678 :     *icc->lpdwFlags = 0;
679 :     ((char*)icc->lpOutput)[0] = 0x7f; /* virtual dub skip frame */
680 :     outhdr->biSizeImage = 1;
681 :    
682 :     }else{
683 :     if (frame.out_flags & XVID_KEYFRAME)
684 :     {
685 :     codec->keyspacing = 0;
686 :     *icc->lpdwFlags = AVIIF_KEYFRAME;
687 :     }
688 :     else
689 :     {
690 :     *icc->lpdwFlags = 0;
691 :     }
692 :    
693 :     outhdr->biSizeImage = length;
694 :    
695 : suxen_drol 983 if (codec->config.mode == RC_MODE_2PASS1 && codec->config.discard1pass)
696 : suxen_drol 889 {
697 :     outhdr->biSizeImage = 0;
698 :     }
699 :     }
700 :    
701 : suxen_drol 1017 codec->framenum++;
702 :     codec->keyspacing++;
703 : suxen_drol 889
704 :     return ICERR_OK;
705 :     }
706 :    
707 :    
708 :     /* decompressor */
709 :    
710 :    
711 :     LRESULT decompress_query(CODEC * codec, BITMAPINFO *lpbiInput, BITMAPINFO *lpbiOutput)
712 :     {
713 :     BITMAPINFOHEADER * inhdr = &lpbiInput->bmiHeader;
714 :     BITMAPINFOHEADER * outhdr = &lpbiOutput->bmiHeader;
715 :    
716 :     if (lpbiInput == NULL)
717 :     {
718 :     return ICERR_ERROR;
719 :     }
720 :    
721 :     if (inhdr->biCompression != FOURCC_XVID && inhdr->biCompression != FOURCC_DIVX && inhdr->biCompression != FOURCC_DX50 && get_colorspace(inhdr) == XVID_CSP_NULL)
722 :     {
723 :     return ICERR_BADFORMAT;
724 :     }
725 :    
726 :     if (lpbiOutput == NULL)
727 :     {
728 :     return ICERR_OK;
729 :     }
730 :    
731 :     if (inhdr->biWidth != outhdr->biWidth ||
732 :     inhdr->biHeight != outhdr->biHeight ||
733 :     get_colorspace(outhdr) == XVID_CSP_NULL)
734 :     {
735 :     return ICERR_BADFORMAT;
736 :     }
737 :    
738 :     return ICERR_OK;
739 :     }
740 :    
741 :    
742 :     LRESULT decompress_get_format(CODEC * codec, BITMAPINFO * lpbiInput, BITMAPINFO * lpbiOutput)
743 :     {
744 :     BITMAPINFOHEADER * inhdr = &lpbiInput->bmiHeader;
745 :     BITMAPINFOHEADER * outhdr = &lpbiOutput->bmiHeader;
746 :     LRESULT result;
747 :    
748 :     if (lpbiOutput == NULL)
749 :     {
750 :     return sizeof(BITMAPINFOHEADER);
751 :     }
752 :    
753 :     /* --- yv12 --- */
754 :    
755 :     if (get_colorspace(inhdr) != XVID_CSP_NULL) {
756 :     memcpy(outhdr, inhdr, sizeof(BITMAPINFOHEADER));
757 : edgomez 1053 /* XXX: should we set outhdr->biSize ?? */
758 : suxen_drol 889 return ICERR_OK;
759 :     }
760 :     /* --- yv12 --- */
761 :    
762 :     result = decompress_query(codec, lpbiInput, lpbiOutput);
763 :     if (result != ICERR_OK)
764 :     {
765 :     return result;
766 :     }
767 :    
768 :     outhdr->biSize = sizeof(BITMAPINFOHEADER);
769 :     outhdr->biWidth = inhdr->biWidth;
770 :     outhdr->biHeight = inhdr->biHeight;
771 :     outhdr->biPlanes = 1;
772 :     outhdr->biBitCount = 24;
773 :     outhdr->biCompression = BI_RGB; /* sonic foundry vegas video v3 only supports BI_RGB */
774 :     outhdr->biSizeImage = outhdr->biWidth * outhdr->biHeight * outhdr->biBitCount;
775 :     outhdr->biXPelsPerMeter = 0;
776 :     outhdr->biYPelsPerMeter = 0;
777 :     outhdr->biClrUsed = 0;
778 :     outhdr->biClrImportant = 0;
779 :    
780 :     return ICERR_OK;
781 :     }
782 :    
783 :    
784 :     LRESULT decompress_begin(CODEC * codec, BITMAPINFO * lpbiInput, BITMAPINFO * lpbiOutput)
785 :     {
786 :     xvid_gbl_init_t init;
787 :     xvid_dec_create_t create;
788 :    
789 :     memset(&init, 0, sizeof(init));
790 :     init.version = XVID_VERSION;
791 :     init.cpu_flags = codec->config.cpu;
792 :     xvid_global(0, XVID_GBL_INIT, &init, NULL);
793 :    
794 :     memset(&create, 0, sizeof(create));
795 :     create.version = XVID_VERSION;
796 :     create.width = lpbiInput->bmiHeader.biWidth;
797 :     create.height = lpbiInput->bmiHeader.biHeight;
798 :    
799 :     switch(xvid_decore(0, XVID_DEC_CREATE, &create, NULL))
800 :     {
801 :     case XVID_ERR_FAIL :
802 :     return ICERR_ERROR;
803 :    
804 :     case XVID_ERR_MEMORY :
805 :     return ICERR_MEMORY;
806 :    
807 :     case XVID_ERR_FORMAT :
808 :     return ICERR_BADFORMAT;
809 :    
810 :     case XVID_ERR_VERSION :
811 :     return ICERR_UNSUPPORTED;
812 :     }
813 :    
814 :     codec->dhandle = create.handle;
815 :    
816 :     return ICERR_OK;
817 :     }
818 :    
819 :    
820 :     LRESULT decompress_end(CODEC * codec)
821 :     {
822 :     if (codec->dhandle != NULL)
823 :     {
824 :     xvid_decore(codec->dhandle, XVID_DEC_DESTROY, NULL, NULL);
825 :     codec->dhandle = NULL;
826 :     }
827 :     return ICERR_OK;
828 :     }
829 :    
830 :    
831 :     LRESULT decompress(CODEC * codec, ICDECOMPRESS * icd)
832 :     {
833 :     xvid_dec_frame_t frame;
834 :    
835 :     /* --- yv12 --- */
836 :     if (icd->lpbiInput->biCompression != FOURCC_XVID &&
837 :     icd->lpbiInput->biCompression != FOURCC_DIVX &&
838 :     icd->lpbiInput->biCompression != FOURCC_DX50)
839 :     {
840 :     xvid_gbl_convert_t convert;
841 :    
842 : suxen_drol 983 DPRINTF("input=%c%c%c%c output=%c%c%c%c",
843 :     icd->lpbiInput->biCompression&0xff,
844 :     (icd->lpbiInput->biCompression>>8)&0xff,
845 :     (icd->lpbiInput->biCompression>>16)&0xff,
846 :     (icd->lpbiInput->biCompression>>24)&0xff,
847 :     icd->lpbiOutput->biCompression&0xff,
848 :     (icd->lpbiOutput->biCompression>>8)&0xff,
849 :     (icd->lpbiOutput->biCompression>>16)&0xff,
850 :     (icd->lpbiOutput->biCompression>>24)&0xff);
851 : suxen_drol 889
852 :     memset(&convert, 0, sizeof(convert));
853 :     convert.version = XVID_VERSION;
854 :    
855 :     convert.input.csp = get_colorspace(icd->lpbiInput);
856 :     convert.input.plane[0] = icd->lpInput;
857 :     convert.input.stride[0] = (((icd->lpbiInput->biWidth *icd->lpbiInput->biBitCount) + 31) & ~31) >> 3;
858 :     if (convert.input.csp == XVID_CSP_I420 || convert.input.csp == XVID_CSP_YV12)
859 :     convert.input.stride[0] = (convert.input.stride[0]*2)/3;
860 :    
861 :     convert.output.csp = get_colorspace(icd->lpbiOutput);
862 :     convert.output.plane[0] = icd->lpOutput;
863 :     convert.output.stride[0] = (((icd->lpbiOutput->biWidth *icd->lpbiOutput->biBitCount) + 31) & ~31) >> 3;
864 :     if (convert.output.csp == XVID_CSP_I420 || convert.output.csp == XVID_CSP_YV12)
865 :     convert.output.stride[0] = (convert.output.stride[0]*2)/3;
866 :    
867 :     convert.width = icd->lpbiInput->biWidth;
868 :     convert.height = icd->lpbiInput->biHeight;
869 :     convert.interlacing = 0;
870 :     if (convert.input.csp == XVID_CSP_NULL ||
871 :     convert.output.csp == XVID_CSP_NULL ||
872 :     xvid_global(0, XVID_GBL_CONVERT, &convert, NULL) < 0)
873 :     {
874 :     return ICERR_BADFORMAT;
875 :     }
876 :     return ICERR_OK;
877 :     }
878 :     /* --- yv12 --- */
879 :    
880 :     memset(&frame, 0, sizeof(frame));
881 :     frame.version = XVID_VERSION;
882 :     frame.general = XVID_LOWDELAY; /* force low_delay_default mode */
883 :     frame.bitstream = icd->lpInput;
884 :     frame.length = icd->lpbiInput->biSizeImage;
885 :    
886 :     if (~((icd->dwFlags & ICDECOMPRESS_HURRYUP) | (icd->dwFlags & ICDECOMPRESS_UPDATE) | (icd->dwFlags & ICDECOMPRESS_PREROLL)))
887 :     {
888 :     if ((frame.output.csp = get_colorspace(icd->lpbiOutput)) == XVID_CSP_NULL)
889 :     {
890 :     return ICERR_BADFORMAT;
891 :     }
892 :     frame.output.plane[0] = icd->lpOutput;
893 :     frame.output.stride[0] = (((icd->lpbiOutput->biWidth * icd->lpbiOutput->biBitCount) + 31) & ~31) >> 3;
894 :     if (frame.output.csp == XVID_CSP_I420 || frame.output.csp == XVID_CSP_YV12)
895 :     frame.output.stride[0] = (frame.output.stride[0]*2)/3;
896 :     }
897 :     else
898 :     {
899 :     frame.output.csp = XVID_CSP_NULL;
900 :     }
901 :    
902 :     switch (xvid_decore(codec->dhandle, XVID_DEC_DECODE, &frame, NULL))
903 :     {
904 :     case XVID_ERR_FAIL :
905 :     return ICERR_ERROR;
906 :    
907 :     case XVID_ERR_MEMORY :
908 :     return ICERR_MEMORY;
909 :    
910 :     case XVID_ERR_FORMAT :
911 :     return ICERR_BADFORMAT;
912 :    
913 :     case XVID_ERR_VERSION :
914 :     return ICERR_UNSUPPORTED;
915 :     }
916 :    
917 :     return ICERR_OK;
918 :     }
919 :    

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