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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 632 - (view) (download)

1 : Isibaar 3 /**************************************************************************
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 : suxen_drol 295 * 12.07.2002 num_threads
27 : suxen_drol 235 * 23.06.2002 XVID_CPU_CHKONLY; loading speed up
28 : suxen_drol 137 * 25.04.2002 ICDECOMPRESS_PREROLL
29 : h 127 * 17.04.2002 re-enabled lumi masking for 1st pass
30 : h 121 * 15.04.2002 updated cbr support
31 : h 102 * 04.04.2002 separated 2-pass code to 2pass.c
32 :     * interlacing support
33 :     * hinted ME support
34 : h 61 * 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 : h 30 * 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 : h 526 * 01.12.2001 inital version; (c)2001 peter ross <pross@xvid.org>
47 : Isibaar 3 *
48 :     *************************************************************************/
49 :    
50 :     #include <windows.h>
51 :     #include <vfw.h>
52 :    
53 :     #include "codec.h"
54 : h 102 #include "2pass.h"
55 : Isibaar 3
56 :     int pmvfast_presets[7] = {
57 : Isibaar 593 0, PMV_QUICKSTOP16, 0, 0,
58 :     0 | PMV_HALFPELREFINE16 | PMV_HALFPELDIAMOND8,
59 :     0 | PMV_HALFPELREFINE16 | PMV_HALFPELDIAMOND8 |
60 :     PMV_ADVANCEDDIAMOND16, PMV_HALFPELREFINE16 | PMV_EXTSEARCH16 |
61 :     PMV_HALFPELREFINE8 | PMV_HALFPELDIAMOND8 | PMV_USESQUARES16
62 : Isibaar 3 };
63 :    
64 :     /* return xvid compatbile colorspace,
65 :     or XVID_CSP_NULL if failure
66 :     */
67 :    
68 : h 30 int get_colorspace(BITMAPINFOHEADER * hdr)
69 : Isibaar 3 {
70 : suxen_drol 595 /* rgb only: negative height specifies top down image */
71 :     int rgb_flip = (hdr->biHeight < 0 ? 0 : XVID_CSP_VFLIP);
72 :    
73 : h 30 switch(hdr->biCompression)
74 : Isibaar 3 {
75 :     case BI_RGB :
76 : h 30 if (hdr->biBitCount == 16)
77 : Isibaar 3 {
78 :     DEBUG("RGB16 (RGB555)");
79 : suxen_drol 595 return rgb_flip | XVID_CSP_RGB555;
80 : Isibaar 3 }
81 : h 30 if (hdr->biBitCount == 24)
82 : Isibaar 3 {
83 :     DEBUG("RGB24");
84 : suxen_drol 595 return rgb_flip | XVID_CSP_RGB24;
85 : Isibaar 3 }
86 : h 30 if (hdr->biBitCount == 32)
87 : Isibaar 3 {
88 :     DEBUG("RGB32");
89 : suxen_drol 595 return rgb_flip | XVID_CSP_RGB32;
90 : Isibaar 3 }
91 :    
92 : suxen_drol 595 DEBUG1("unsupported BI_RGB biBitCount", hdr->biBitCount);
93 : Isibaar 3 return XVID_CSP_NULL;
94 :    
95 : suxen_drol 595 case BI_BITFIELDS :
96 :     if (hdr->biSize >= sizeof(BITMAPV4HEADER))
97 : Isibaar 3 {
98 : suxen_drol 595 BITMAPV4HEADER * hdr4 = (BITMAPV4HEADER *)hdr;
99 :    
100 :     if (hdr4->bV4BitCount == 16 &&
101 :     hdr4->bV4RedMask == 0x7c00 &&
102 :     hdr4->bV4GreenMask == 0x3e0 &&
103 :     hdr4->bV4BlueMask == 0x1f)
104 :     {
105 :     DEBUG("RGB555");
106 :     return rgb_flip | XVID_CSP_RGB555;
107 :     }
108 :    
109 :     if(hdr4->bV4BitCount == 16 &&
110 :     hdr4->bV4RedMask == 0xf800 &&
111 :     hdr4->bV4GreenMask == 0x7e0 &&
112 :     hdr4->bV4BlueMask == 0x1f)
113 :     {
114 :     DEBUG("RGB565");
115 :     return rgb_flip | XVID_CSP_RGB565;
116 :     }
117 :    
118 :     DEBUG("unsupported BI_BITFIELDS mode");
119 :     return XVID_CSP_NULL;
120 : Isibaar 3 }
121 :    
122 : suxen_drol 595 DEBUG("unsupported BI_BITFIELDS/BITMAPHEADER combination");
123 : Isibaar 3 return XVID_CSP_NULL;
124 : suxen_drol 595
125 :     case FOURCC_I420 :
126 :     case FOURCC_IYUV :
127 : Isibaar 3 DEBUG("IYUY");
128 :     return XVID_CSP_I420;
129 :    
130 :     case FOURCC_YV12 :
131 :     DEBUG("YV12");
132 :     return XVID_CSP_YV12;
133 : suxen_drol 625
134 : Isibaar 3 case FOURCC_YUYV :
135 :     case FOURCC_YUY2 :
136 :     DEBUG("YUY2");
137 :     return XVID_CSP_YUY2;
138 :    
139 : suxen_drol 595 case FOURCC_YVYU :
140 : Isibaar 3 DEBUG("YVYU");
141 :     return XVID_CSP_YVYU;
142 :    
143 : suxen_drol 595 case FOURCC_UYVY :
144 : Isibaar 3 DEBUG("UYVY");
145 :     return XVID_CSP_UYVY;
146 :    
147 : suxen_drol 595 default :
148 :     DEBUGFOURCC("unsupported colorspace", hdr->biCompression);
149 :     return XVID_CSP_NULL;
150 : Isibaar 3 }
151 :     }
152 :    
153 :    
154 :     /* compressor */
155 :    
156 :    
157 :     /* test the output format */
158 :    
159 :     LRESULT compress_query(CODEC * codec, BITMAPINFO * lpbiInput, BITMAPINFO * lpbiOutput)
160 :     {
161 : h 30 BITMAPINFOHEADER * inhdr = &lpbiInput->bmiHeader;
162 :     BITMAPINFOHEADER * outhdr = &lpbiOutput->bmiHeader;
163 : Isibaar 3
164 :     if (get_colorspace(inhdr) == XVID_CSP_NULL)
165 :     {
166 :     return ICERR_BADFORMAT;
167 :     }
168 :    
169 :     if (lpbiOutput == NULL)
170 :     {
171 :     return ICERR_OK;
172 :     }
173 : h 30
174 :     if (inhdr->biWidth != outhdr->biWidth || inhdr->biHeight != outhdr->biHeight ||
175 :     (outhdr->biCompression != FOURCC_XVID && outhdr->biCompression != FOURCC_DIVX))
176 : Isibaar 3 {
177 :     return ICERR_BADFORMAT;
178 :     }
179 :    
180 :     return ICERR_OK;
181 :     }
182 :    
183 :    
184 :     LRESULT compress_get_format(CODEC * codec, BITMAPINFO * lpbiInput, BITMAPINFO * lpbiOutput)
185 :     {
186 : h 30 BITMAPINFOHEADER * inhdr = &lpbiInput->bmiHeader;
187 :     BITMAPINFOHEADER * outhdr = &lpbiOutput->bmiHeader;
188 : Isibaar 3
189 : h 30 if (get_colorspace(inhdr) == XVID_CSP_NULL)
190 : Isibaar 3 {
191 : h 30 return ICERR_BADFORMAT;
192 : Isibaar 3 }
193 :    
194 :     if (lpbiOutput == NULL)
195 :     {
196 :     return sizeof(BITMAPV4HEADER);
197 :     }
198 :    
199 : h 30 memcpy(outhdr, inhdr, sizeof(BITMAPINFOHEADER));
200 :     outhdr->biSize = sizeof(BITMAPINFOHEADER);
201 :     outhdr->biSizeImage = compress_get_size(codec, lpbiInput, lpbiOutput);
202 :     outhdr->biXPelsPerMeter = 0;
203 :     outhdr->biYPelsPerMeter = 0;
204 :     outhdr->biClrUsed = 0;
205 :     outhdr->biClrImportant = 0;
206 : Isibaar 3
207 :     if (codec->config.fourcc_used == 0)
208 :     {
209 : h 30 outhdr->biCompression = FOURCC_XVID;
210 : Isibaar 3 }
211 : h 30 else if (codec->config.fourcc_used == 1)
212 :     {
213 :     outhdr->biCompression = FOURCC_DIVX;
214 :     }
215 : Isibaar 3 else
216 :     {
217 : h 30 outhdr->biCompression = FOURCC_DX50;
218 : Isibaar 3 }
219 :    
220 :     return ICERR_OK;
221 :     }
222 :    
223 :    
224 :     LRESULT compress_get_size(CODEC * codec, BITMAPINFO * lpbiInput, BITMAPINFO * lpbiOutput)
225 :     {
226 : suxen_drol 228 return
227 :     #ifdef BFRAMES
228 :     2 *
229 :     #endif
230 :     lpbiOutput->bmiHeader.biWidth * lpbiOutput->bmiHeader.biHeight * 3;
231 : Isibaar 3 }
232 :    
233 :    
234 :     LRESULT compress_frames_info(CODEC * codec, ICCOMPRESSFRAMES * icf)
235 :     {
236 :     // DEBUG2("frate fscale", codec->frate, codec->fscale);
237 :     codec->fincr = icf->dwScale;
238 :     codec->fbase = icf->dwRate;
239 :     return ICERR_OK;
240 :     }
241 :    
242 :    
243 :     LRESULT compress_begin(CODEC * codec, BITMAPINFO * lpbiInput, BITMAPINFO * lpbiOutput)
244 :     {
245 :     XVID_ENC_PARAM param;
246 :     XVID_INIT_PARAM init_param;
247 :    
248 :     switch (codec->config.mode)
249 :     {
250 :     case DLG_MODE_CBR :
251 : h 121 param.rc_bitrate = codec->config.rc_bitrate;
252 :     param.rc_reaction_delay_factor = codec->config.rc_reaction_delay_factor;
253 :     param.rc_averaging_period = codec->config.rc_averaging_period;
254 :     param.rc_buffer = codec->config.rc_buffer;
255 : Isibaar 3 break;
256 :    
257 :     case DLG_MODE_VBR_QUAL :
258 :     codec->config.fquant = 0;
259 : h 121 param.rc_bitrate = 0;
260 : Isibaar 3 break;
261 :    
262 :     case DLG_MODE_VBR_QUANT :
263 :     codec->config.fquant = (float) codec->config.quant;
264 : h 121 param.rc_bitrate = 0;
265 : Isibaar 3 break;
266 :    
267 : h 61 case DLG_MODE_2PASS_1 :
268 :     case DLG_MODE_2PASS_2_INT :
269 :     case DLG_MODE_2PASS_2_EXT :
270 : h 121 param.rc_bitrate = 0;
271 : h 109 codec->twopass.max_framesize = (int)((double)codec->config.twopass_max_bitrate / 8.0 / ((double)codec->fbase / (double)codec->fincr));
272 : Isibaar 3 break;
273 :    
274 : h 61 case DLG_MODE_NULL :
275 :     return ICERR_OK;
276 :    
277 : Isibaar 3 default :
278 :     break;
279 :     }
280 :    
281 :     if(codec->ehandle)
282 :     {
283 :     xvid_encore(codec->ehandle, XVID_ENC_DESTROY, NULL, NULL);
284 :     codec->ehandle = NULL;
285 :     }
286 :    
287 :     init_param.cpu_flags = codec->config.cpu;
288 :     xvid_init(0, 0, &init_param, NULL);
289 :     if((codec->config.cpu & XVID_CPU_FORCE) <= 0)
290 :     codec->config.cpu = init_param.cpu_flags;
291 :    
292 : h 30 param.width = lpbiInput->bmiHeader.biWidth;
293 :     param.height = lpbiInput->bmiHeader.biHeight;
294 : Isibaar 3 param.fincr = codec->fincr;
295 :     param.fbase = codec->fbase;
296 :    
297 : h 30 param.min_quantizer = codec->config.min_pquant;
298 :     param.max_quantizer = codec->config.max_pquant;
299 : Isibaar 3 param.max_key_interval = codec->config.max_key_interval;
300 :    
301 : suxen_drol 295 #ifdef _SMP
302 :     param.num_threads = codec->config.num_threads;
303 :     #endif
304 :    
305 : suxen_drol 228 #ifdef BFRAMES
306 : suxen_drol 235 param.global = 0;
307 :     if (codec->config.packed) param.global |= XVID_GLOBAL_PACKED;
308 :     if (codec->config.dx50bvop) param.global |= XVID_GLOBAL_DX50BVOP;
309 :     if (codec->config.debug) param.global |= XVID_GLOBAL_DEBUG;
310 : suxen_drol 228 param.max_bframes = codec->config.max_bframes;
311 :     param.bquant_ratio = codec->config.bquant_ratio;
312 : suxen_drol 324 param.frame_drop_ratio = codec->config.frame_drop_ratio;
313 : suxen_drol 228 #endif
314 :    
315 : Isibaar 3 switch(xvid_encore(0, XVID_ENC_CREATE, &param, NULL))
316 :     {
317 :     case XVID_ERR_FAIL :
318 :     return ICERR_ERROR;
319 :    
320 :     case XVID_ERR_MEMORY :
321 :     return ICERR_MEMORY;
322 :    
323 :     case XVID_ERR_FORMAT :
324 :     return ICERR_BADFORMAT;
325 :     }
326 :    
327 :     codec->ehandle = param.handle;
328 :     codec->framenum = 0;
329 :     codec->keyspacing = 0;
330 :    
331 : h 102 codec->twopass.hints = codec->twopass.stats1 = codec->twopass.stats2 = INVALID_HANDLE_VALUE;
332 :     codec->twopass.hintstream = NULL;
333 : Isibaar 3
334 :     return ICERR_OK;
335 :     }
336 :    
337 :    
338 :     LRESULT compress_end(CODEC * codec)
339 :     {
340 :     if (codec->ehandle != NULL)
341 :     {
342 :     xvid_encore(codec->ehandle, XVID_ENC_DESTROY, NULL, NULL);
343 : h 102
344 :     if (codec->twopass.hints != INVALID_HANDLE_VALUE)
345 :     {
346 :     CloseHandle(codec->twopass.hints);
347 :     }
348 : Isibaar 3 if (codec->twopass.stats1 != INVALID_HANDLE_VALUE)
349 :     {
350 :     CloseHandle(codec->twopass.stats1);
351 :     }
352 :     if (codec->twopass.stats2 != INVALID_HANDLE_VALUE)
353 :     {
354 :     CloseHandle(codec->twopass.stats2);
355 :     }
356 : h 102 if (codec->twopass.hintstream != NULL)
357 :     {
358 :     free(codec->twopass.hintstream);
359 :     }
360 :    
361 : Isibaar 3 codec->ehandle = NULL;
362 : h 105
363 :     codec_2pass_finish(codec);
364 : Isibaar 3 }
365 :    
366 :     return ICERR_OK;
367 :     }
368 :    
369 :    
370 :     LRESULT compress(CODEC * codec, ICCOMPRESS * icc)
371 :     {
372 : h 30 BITMAPINFOHEADER * inhdr = icc->lpbiInput;
373 :     BITMAPINFOHEADER * outhdr = icc->lpbiOutput;
374 : Isibaar 3 XVID_ENC_FRAME frame;
375 :     XVID_ENC_STATS stats;
376 :    
377 :     // mpeg2avi yuv bug workaround (2 instances of CODEC)
378 :     if (codec->twopass.stats1 == INVALID_HANDLE_VALUE)
379 :     {
380 :     if (codec_2pass_init(codec) == ICERR_ERROR)
381 :     {
382 :     return ICERR_ERROR;
383 :     }
384 :     }
385 :    
386 :     frame.general = 0;
387 :     frame.motion = 0;
388 : h 30 frame.intra = -1;
389 : Isibaar 3
390 :     frame.general |= XVID_HALFPEL;
391 : Isibaar 364 // frame.general |= XVID_ME_EPZS;
392 : Isibaar 3
393 : Isibaar 364
394 : h 127 if (codec->config.motion_search > 4)
395 : Isibaar 3 frame.general |= XVID_INTER4V;
396 :    
397 : h 127 if (codec->config.lum_masking)
398 : Isibaar 3 frame.general |= XVID_LUMIMASKING;
399 :    
400 : h 102 if (codec->config.interlacing)
401 : Isibaar 364 frame.general |= XVID_INTERLACING;
402 : chl 355
403 : Isibaar 364
404 : suxen_drol 632
405 : Isibaar 364 // added by koepi for credits greyscale
406 :    
407 :     check_greyscale_mode(&codec->config, &frame, codec->framenum);
408 :    
409 :     // end of koepi's addition
410 :    
411 :    
412 : Isibaar 176 // fix 1pass modes/hinted MV by koepi
413 :     if (codec->config.hinted_me && (codec->config.mode == DLG_MODE_CBR || codec->config.mode == DLG_MODE_VBR_QUAL || codec->config.mode == DLG_MODE_VBR_QUANT))
414 :     {
415 :     codec->config.hinted_me = 0;
416 :     }
417 :     // end of ugly hack
418 : h 102
419 :     if (codec->config.hinted_me && codec->config.mode == DLG_MODE_2PASS_1)
420 :     {
421 :     frame.hint.hintstream = codec->twopass.hintstream;
422 :     frame.hint.rawhints = 0;
423 :     frame.general |= XVID_HINTEDME_GET;
424 :     }
425 : h 103 else if (codec->config.hinted_me && (codec->config.mode == DLG_MODE_2PASS_2_EXT || codec->config.mode == DLG_MODE_2PASS_2_INT))
426 : h 102 {
427 :     DWORD read;
428 :     DWORD blocksize;
429 :    
430 :     frame.hint.hintstream = codec->twopass.hintstream;
431 :     frame.hint.rawhints = 0;
432 :     frame.general |= XVID_HINTEDME_SET;
433 :    
434 :     if (codec->twopass.hints == INVALID_HANDLE_VALUE)
435 :     {
436 :     codec->twopass.hints = CreateFile(codec->config.hintfile, GENERIC_READ, 0, 0, OPEN_EXISTING, 0, 0);
437 :     if (codec->twopass.hints == INVALID_HANDLE_VALUE)
438 :     {
439 :     DEBUGERR("couldn't open hints file");
440 :     return ICERR_ERROR;
441 :     }
442 :     }
443 :     if (!ReadFile(codec->twopass.hints, &blocksize, sizeof(DWORD), &read, 0) || read != sizeof(DWORD) ||
444 :     !ReadFile(codec->twopass.hints, frame.hint.hintstream, blocksize, &read, 0) || read != blocksize)
445 :     {
446 :     DEBUGERR("couldn't read from hints file");
447 :     return ICERR_ERROR;
448 :     }
449 :     }
450 :    
451 : Isibaar 3 frame.motion = pmvfast_presets[codec->config.motion_search];
452 : h 30
453 : Isibaar 3 frame.image = icc->lpInput;
454 : suxen_drol 632 // dev-api-3
455 :     frame.stride = (((icc->lpbiInput->biWidth * icc->lpbiInput->biBitCount) + 31) & ~31) >> 3;
456 : Isibaar 3
457 : h 30 if ((frame.colorspace = get_colorspace(inhdr)) == XVID_CSP_NULL)
458 : Isibaar 3 return ICERR_BADFORMAT;
459 :    
460 :     frame.bitstream = icc->lpOutput;
461 :     frame.length = icc->lpbiOutput->biSizeImage;
462 :    
463 :     switch (codec->config.mode)
464 :     {
465 :     case DLG_MODE_CBR :
466 :     frame.quant = 0;
467 :     break;
468 :    
469 :     case DLG_MODE_VBR_QUAL :
470 :     case DLG_MODE_VBR_QUANT :
471 :     case DLG_MODE_2PASS_1 :
472 :     if (codec_get_quant(codec, &frame) == ICERR_ERROR)
473 :     {
474 :     return ICERR_ERROR;
475 :     }
476 :     break;
477 :    
478 :     case DLG_MODE_2PASS_2_EXT :
479 :     case DLG_MODE_2PASS_2_INT :
480 :     if (codec_2pass_get_quant(codec, &frame) == ICERR_ERROR)
481 :     {
482 :     return ICERR_ERROR;
483 :     }
484 :     if (codec->config.dummy2pass)
485 :     {
486 : h 30 outhdr->biSizeImage = codec->twopass.bytes2;
487 : Isibaar 3 *icc->lpdwFlags = (codec->twopass.nns1.quant & NNSTATS_KEYFRAME) ? AVIIF_KEYFRAME : 0;
488 :     return ICERR_OK;
489 :     }
490 :     break;
491 :    
492 :     case DLG_MODE_NULL :
493 : h 30 outhdr->biSizeImage = 0;
494 : Isibaar 3 *icc->lpdwFlags = AVIIF_KEYFRAME;
495 :     return ICERR_OK;
496 :    
497 :     default :
498 : h 61 DEBUGERR("Invalid encoding mode");
499 : Isibaar 3 return ICERR_ERROR;
500 :     }
501 :    
502 : h 30 if (codec->config.quant_type == QUANT_MODE_H263)
503 : Isibaar 3 {
504 : h 30 frame.general |= XVID_H263QUANT;
505 :     }
506 :     else
507 :     {
508 :     frame.general |= XVID_MPEGQUANT;
509 :    
510 :     // we actually need "default/custom" selectbox for both inter/intra
511 :     // this will do for now
512 :     if (codec->config.quant_type == QUANT_MODE_CUSTOM)
513 :     {
514 :     frame.general |= XVID_CUSTOM_QMATRIX;
515 :     frame.quant_intra_matrix = codec->config.qmatrix_intra;
516 :     frame.quant_inter_matrix = codec->config.qmatrix_inter;
517 :     }
518 :     else
519 :     {
520 :     frame.quant_intra_matrix = NULL;
521 :     frame.quant_inter_matrix = NULL;
522 :     }
523 :     }
524 :    
525 :     // force keyframe spacing in 2-pass 1st pass
526 :     if (codec->config.motion_search == 0)
527 :     {
528 :     frame.intra = 1;
529 :     }
530 : h 109 else if (codec->keyspacing < codec->config.min_key_interval && codec->framenum)
531 : h 30 {
532 : Isibaar 3 DEBUG("current frame forced to p-frame");
533 :     frame.intra = 0;
534 :     }
535 :    
536 : suxen_drol 278 #ifdef BFRAMES
537 :     frame.bquant = 0;
538 :     #endif
539 :    
540 : suxen_drol 324 // OutputDebugString(" ");
541 : Isibaar 3 switch (xvid_encore(codec->ehandle, XVID_ENC_ENCODE, &frame, &stats))
542 :     {
543 :     case XVID_ERR_FAIL :
544 :     return ICERR_ERROR;
545 :    
546 :     case XVID_ERR_MEMORY :
547 :     return ICERR_MEMORY;
548 :    
549 :     case XVID_ERR_FORMAT :
550 :     return ICERR_BADFORMAT;
551 :     }
552 :    
553 :     if (frame.intra)
554 :     {
555 :     codec->keyspacing = 0;
556 :     *icc->lpdwFlags = AVIIF_KEYFRAME;
557 :     }
558 :     else
559 :     {
560 :     *icc->lpdwFlags = 0;
561 :     }
562 :    
563 : h 30 outhdr->biSizeImage = frame.length;
564 : Isibaar 3
565 : h 30 if (codec->config.mode == DLG_MODE_2PASS_1 && codec->config.discard1pass)
566 : Isibaar 3 {
567 : h 30 outhdr->biSizeImage = 0;
568 : Isibaar 3 }
569 :    
570 : h 102 if (frame.general & XVID_HINTEDME_GET)
571 :     {
572 :     DWORD wrote;
573 :     DWORD blocksize = frame.hint.hintlength;
574 :    
575 :     if (codec->twopass.hints == INVALID_HANDLE_VALUE)
576 :     {
577 :     codec->twopass.hints = CreateFile(codec->config.hintfile, GENERIC_WRITE, 0, 0, CREATE_ALWAYS, 0, 0);
578 : suxen_drol 228 if (codec->twopass.hints == INVALID_HANDLE_VALUE)
579 : h 102 {
580 :     DEBUGERR("couldn't create hints file");
581 :     return ICERR_ERROR;
582 :     }
583 :     }
584 :     if (!WriteFile(codec->twopass.hints, &frame.hint.hintlength, sizeof(int), &wrote, 0) || wrote != sizeof(int) ||
585 :     !WriteFile(codec->twopass.hints, frame.hint.hintstream, blocksize, &wrote, 0) || wrote != blocksize)
586 :     {
587 :     DEBUGERR("couldn't write to hints file");
588 :     return ICERR_ERROR;
589 :     }
590 :     }
591 :    
592 : Isibaar 3 codec_2pass_update(codec, &frame, &stats);
593 :    
594 :     ++codec->framenum;
595 :     ++codec->keyspacing;
596 :    
597 :     return ICERR_OK;
598 :     }
599 :    
600 :    
601 :     /* decompressor */
602 :    
603 :    
604 :     LRESULT decompress_query(CODEC * codec, BITMAPINFO *lpbiInput, BITMAPINFO *lpbiOutput)
605 :     {
606 : h 30 BITMAPINFOHEADER * inhdr = &lpbiInput->bmiHeader;
607 :     BITMAPINFOHEADER * outhdr = &lpbiOutput->bmiHeader;
608 : Isibaar 3
609 :     if (lpbiInput == NULL)
610 :     {
611 :     return ICERR_ERROR;
612 :     }
613 : suxen_drol 625 /* --- yv12 --- */
614 :     if (inhdr->biCompression == FOURCC_YV12) {
615 :     return ICERR_OK;
616 :     }
617 :     /* --- yv12 --- */
618 : Isibaar 3
619 : h 30 if (inhdr->biCompression != FOURCC_XVID && inhdr->biCompression != FOURCC_DIVX)
620 : Isibaar 3 {
621 :     return ICERR_BADFORMAT;
622 :     }
623 :    
624 :     if (lpbiOutput == NULL)
625 :     {
626 :     return ICERR_OK;
627 :     }
628 :    
629 : h 30 if (inhdr->biWidth != outhdr->biWidth ||
630 :     inhdr->biHeight != outhdr->biHeight ||
631 : Isibaar 3 get_colorspace(outhdr) == XVID_CSP_NULL)
632 :     {
633 :     return ICERR_BADFORMAT;
634 :     }
635 :    
636 :     return ICERR_OK;
637 :     }
638 :    
639 :    
640 :     LRESULT decompress_get_format(CODEC * codec, BITMAPINFO * lpbiInput, BITMAPINFO * lpbiOutput)
641 :     {
642 : h 30 BITMAPINFOHEADER * inhdr = &lpbiInput->bmiHeader;
643 :     BITMAPINFOHEADER * outhdr = &lpbiOutput->bmiHeader;
644 : Isibaar 3 LRESULT result;
645 :    
646 :     if (lpbiOutput == NULL)
647 :     {
648 : h 30 return sizeof(BITMAPINFOHEADER);
649 : Isibaar 3 }
650 :    
651 : suxen_drol 625 /* --- yv12 --- */
652 :    
653 :     if (lpbiInput->bmiHeader.biCompression == FOURCC_YV12) {
654 :     memcpy(outhdr, inhdr, sizeof(BITMAPINFOHEADER));
655 :     return ICERR_OK;
656 :     }
657 :     /* --- yv12 --- */
658 :    
659 : Isibaar 3 result = decompress_query(codec, lpbiInput, lpbiOutput);
660 :     if (result != ICERR_OK)
661 :     {
662 :     return result;
663 :     }
664 :    
665 : h 30 memcpy(outhdr, inhdr, sizeof(BITMAPINFOHEADER));
666 :     outhdr->biSize = sizeof(BITMAPINFOHEADER);
667 :     outhdr->biCompression = FOURCC_YUY2;
668 :     outhdr->biSizeImage = outhdr->biWidth * outhdr->biHeight * outhdr->biBitCount;
669 :     outhdr->biXPelsPerMeter = 0;
670 :     outhdr->biYPelsPerMeter = 0;
671 :     outhdr->biClrUsed = 0;
672 :     outhdr->biClrImportant = 0;
673 : Isibaar 3
674 :     return ICERR_OK;
675 :     }
676 :    
677 :    
678 :     LRESULT decompress_begin(CODEC * codec, BITMAPINFO * lpbiInput, BITMAPINFO * lpbiOutput)
679 :     {
680 :     XVID_DEC_PARAM param;
681 :     XVID_INIT_PARAM init_param;
682 :    
683 :     init_param.cpu_flags = codec->config.cpu;
684 :     xvid_init(0, 0, &init_param, NULL);
685 :     if((codec->config.cpu & XVID_CPU_FORCE) <= 0)
686 :     {
687 :     codec->config.cpu = init_param.cpu_flags;
688 :     }
689 :    
690 : h 30 param.width = lpbiInput->bmiHeader.biWidth;
691 :     param.height = lpbiInput->bmiHeader.biHeight;
692 : Isibaar 3
693 :     switch(xvid_decore(0, XVID_DEC_CREATE, &param, NULL))
694 :     {
695 :     case XVID_ERR_FAIL :
696 :     return ICERR_ERROR;
697 :    
698 :     case XVID_ERR_MEMORY :
699 :     return ICERR_MEMORY;
700 :    
701 :     case XVID_ERR_FORMAT :
702 :     return ICERR_BADFORMAT;
703 :     }
704 :    
705 :     codec->dhandle = param.handle;
706 :    
707 :     return ICERR_OK;
708 :     }
709 :    
710 :    
711 :     LRESULT decompress_end(CODEC * codec)
712 :     {
713 :     if (codec->dhandle != NULL)
714 :     {
715 :     xvid_decore(codec->dhandle, XVID_DEC_DESTROY, NULL, NULL);
716 :     codec->dhandle = NULL;
717 :     }
718 :     return ICERR_OK;
719 :     }
720 :    
721 :    
722 :     LRESULT decompress(CODEC * codec, ICDECOMPRESS * icd)
723 :     {
724 :     XVID_DEC_FRAME frame;
725 :    
726 :     frame.bitstream = icd->lpInput;
727 :     frame.length = icd->lpbiInput->biSizeImage;
728 :    
729 :     frame.image = icd->lpOutput;
730 : suxen_drol 632 //frame.stride = icd->lpbiOutput->biWidth;
731 :     // dev-api-3:
732 :     frame.stride = (((icd->lpbiOutput->biWidth * icd->lpbiOutput->biBitCount) + 31) & ~31) >> 3;
733 : Isibaar 3
734 : suxen_drol 625 /* --- yv12 --- */
735 :     if (icd->lpbiInput->biCompression == FOURCC_YV12) {
736 :     DEBUGFOURCC("output", icd->lpbiOutput->biCompression);
737 :     if (icd->lpbiOutput->biCompression == FOURCC_YV12) {
738 :     memcpy(frame.image,codec->dhandle,icd->lpbiInput->biSizeImage);
739 :     }
740 :     return ICERR_OK;
741 :     }
742 :     /* --- yv12 --- */
743 :    
744 :    
745 : suxen_drol 137 if (~((icd->dwFlags & ICDECOMPRESS_HURRYUP) | (icd->dwFlags & ICDECOMPRESS_UPDATE) | (icd->dwFlags & ICDECOMPRESS_PREROLL)))
746 : Isibaar 3 {
747 : h 30 if ((frame.colorspace = get_colorspace(icd->lpbiOutput)) == XVID_CSP_NULL)
748 : Isibaar 3 {
749 :     return ICERR_BADFORMAT;
750 :     }
751 :     }
752 :     else
753 :     {
754 :     frame.colorspace = XVID_CSP_NULL;
755 :     }
756 :    
757 :     switch (xvid_decore(codec->dhandle, XVID_DEC_DECODE, &frame, NULL))
758 :     {
759 :     case XVID_ERR_FAIL :
760 :     return ICERR_ERROR;
761 :    
762 :     case XVID_ERR_MEMORY :
763 :     return ICERR_MEMORY;
764 :    
765 :     case XVID_ERR_FORMAT :
766 :     return ICERR_BADFORMAT;
767 :     }
768 :    
769 :     return ICERR_OK;
770 :     }
771 :    
772 :     int codec_get_quant(CODEC* codec, XVID_ENC_FRAME* frame)
773 :     {
774 :     switch (codec->config.mode)
775 :     {
776 :     case DLG_MODE_VBR_QUAL :
777 :     if (codec_is_in_credits(&codec->config, codec->framenum))
778 :     {
779 : Isibaar 364 // added by koepi for credits greyscale
780 :    
781 :     check_greyscale_mode(&codec->config, frame, codec->framenum);
782 :    
783 :     // end of koepi's addition
784 :    
785 : Isibaar 3 switch (codec->config.credits_mode)
786 :     {
787 :     case CREDITS_MODE_RATE :
788 :     frame->quant = codec_get_vbr_quant(&codec->config, codec->config.quality * codec->config.credits_rate / 100);
789 :     break;
790 :    
791 :     case CREDITS_MODE_QUANT :
792 :     frame->quant = codec->config.credits_quant_p;
793 :     break;
794 :    
795 :     default :
796 : h 61 DEBUGERR("Can't use credits size mode in quality mode");
797 : Isibaar 3 return ICERR_ERROR;
798 :     }
799 :     }
800 :     else
801 :     {
802 : Isibaar 364 // added by koepi for credits greyscale
803 :    
804 :     check_greyscale_mode(&codec->config, frame, codec->framenum);
805 :    
806 :     // end of koepi's addition
807 :    
808 : Isibaar 3 frame->quant = codec_get_vbr_quant(&codec->config, codec->config.quality);
809 :     }
810 :     return ICERR_OK;
811 :    
812 :     case DLG_MODE_VBR_QUANT :
813 :     if (codec_is_in_credits(&codec->config, codec->framenum))
814 :     {
815 : Isibaar 364 // added by koepi for credits greyscale
816 :    
817 :     check_greyscale_mode(&codec->config, frame, codec->framenum);
818 :    
819 :     // end of koepi's addition
820 :    
821 : Isibaar 3 switch (codec->config.credits_mode)
822 :     {
823 :     case CREDITS_MODE_RATE :
824 :     frame->quant =
825 : h 30 codec->config.max_pquant -
826 :     ((codec->config.max_pquant - codec->config.quant) * codec->config.credits_rate / 100);
827 : Isibaar 3 break;
828 :    
829 :     case CREDITS_MODE_QUANT :
830 :     frame->quant = codec->config.credits_quant_p;
831 :     break;
832 :    
833 :     default :
834 : h 61 DEBUGERR("Can't use credits size mode in quantizer mode");
835 : Isibaar 3 return ICERR_ERROR;
836 :     }
837 :     }
838 :     else
839 :     {
840 : Isibaar 364 // added by koepi for credits greyscale
841 :    
842 :     check_greyscale_mode(&codec->config, frame, codec->framenum);
843 :    
844 :     // end of koepi's addition
845 :    
846 : Isibaar 3 frame->quant = codec->config.quant;
847 :     }
848 :     return ICERR_OK;
849 :    
850 :     case DLG_MODE_2PASS_1 :
851 : Isibaar 364 // added by koepi for credits greyscale
852 :    
853 :     check_greyscale_mode(&codec->config, frame, codec->framenum);
854 :    
855 :     // end of koepi's addition
856 :    
857 : Isibaar 3 if (codec->config.credits_mode == CREDITS_MODE_QUANT)
858 :     {
859 :     if (codec_is_in_credits(&codec->config, codec->framenum))
860 :     {
861 :     frame->quant = codec->config.credits_quant_p;
862 :     }
863 :     else
864 :     {
865 :     frame->quant = 2;
866 :     }
867 :     }
868 :     else
869 :     {
870 :     frame->quant = 2;
871 :     }
872 :     return ICERR_OK;
873 :    
874 :     default:
875 : h 61 DEBUGERR("get quant: invalid mode");
876 : Isibaar 3 return ICERR_ERROR;
877 :     }
878 :     }
879 :    
880 :    
881 :     int codec_is_in_credits(CONFIG* config, int framenum)
882 :     {
883 :     if (config->credits_start)
884 :     {
885 :     if (framenum >= config->credits_start_begin &&
886 :     framenum <= config->credits_start_end)
887 :     {
888 :     return CREDITS_START;
889 :     }
890 :     }
891 :    
892 :     if (config->credits_end)
893 :     {
894 :     if (framenum >= config->credits_end_begin &&
895 :     framenum <= config->credits_end_end)
896 :     {
897 :     return CREDITS_END;
898 :     }
899 :     }
900 :    
901 :     return 0;
902 :     }
903 :    
904 :    
905 :     int codec_get_vbr_quant(CONFIG* config, int quality)
906 :     {
907 :     static float fquant_running = 0;
908 :     static int my_quality = -1;
909 :     int quant;
910 :    
911 :     // if quality changes, recalculate fquant (credits)
912 :     if (quality != my_quality)
913 :     {
914 :     config->fquant = 0;
915 :     }
916 :    
917 :     my_quality = quality;
918 :    
919 :     // desired quantiser = (maxQ-minQ)/100 * (100-qual) + minQ
920 :     if (!config->fquant)
921 :     {
922 :     config->fquant =
923 : h 30 ((float) (config->max_pquant - config->min_pquant) / 100) *
924 : Isibaar 3 (100 - quality) +
925 : h 30 (float) config->min_pquant;
926 : Isibaar 3
927 :     fquant_running = config->fquant;
928 :     }
929 :    
930 : h 30 if (fquant_running < config->min_pquant)
931 : Isibaar 3 {
932 : h 30 fquant_running = (float) config->min_pquant;
933 : Isibaar 3 }
934 : h 30 else if(fquant_running > config->max_pquant)
935 : Isibaar 3 {
936 : h 30 fquant_running = (float) config->max_pquant;
937 : Isibaar 3 }
938 :    
939 :     quant = (int) fquant_running;
940 :    
941 :     // add error between fquant and quant to fquant_running
942 :     fquant_running += config->fquant - quant;
943 :    
944 :     return quant;
945 :     }
946 :    
947 : Isibaar 364 // added by koepi for credits greyscale
948 :    
949 :     int check_greyscale_mode(CONFIG* config, XVID_ENC_FRAME* frame, int framenum)
950 :    
951 :     {
952 :    
953 :     if ((codec_is_in_credits(config, framenum)) && (config->mode!=DLG_MODE_CBR))
954 :    
955 :     {
956 :    
957 :     if (config->credits_greyscale)
958 :    
959 :     {
960 :    
961 :     if ((frame->general && XVID_GREYSCALE)) // use only if not already in greyscale
962 :    
963 :     frame->general |= XVID_GREYSCALE;
964 :    
965 :     } else {
966 :    
967 :     if (!(frame->general && XVID_GREYSCALE)) // if movie is in greyscale, switch back
968 :    
969 :     frame->general |= XVID_GREYSCALE;
970 :    
971 :     }
972 :    
973 :     } else {
974 :    
975 :     if (config->greyscale)
976 :    
977 :     {
978 :    
979 :     if ((frame->general && XVID_GREYSCALE)) // use only if not already in greyscale
980 :    
981 :     frame->general |= XVID_GREYSCALE;
982 :    
983 :     } else {
984 :    
985 :     if (!(frame->general && XVID_GREYSCALE)) // if credits is in greyscale, switch back
986 :    
987 :     frame->general |= XVID_GREYSCALE;
988 :    
989 :     }
990 :    
991 :     }
992 :    
993 :     return 0;
994 :    
995 :     }
996 :    
997 :     // end of koepi's addition
998 :    

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