Diff of /trunk/vfw/src/codec.c

-revision 61, Sat Mar 23 06:58:56 2002 UTC
+revision 901, Sun Mar  2 11:53:48 2003 UTC
 Line 23
   *
   *      History:
   *
+  *      12.07.2002      num_threads
+  *      23.06.2002      XVID_CPU_CHKONLY; loading speed up
+  *      25.04.2002      ICDECOMPRESS_PREROLL
+  *      17.04.2002      re-enabled lumi masking for 1st pass
+  *      15.04.2002      updated cbr support
+  *      04.04.2002      separated 2-pass code to 2pass.c
+  *                              interlacing support
+  *                              hinted ME support
   *      23.03.2002      daniel smith <danielsmith@astroboymail.com>
   *                              changed inter4v to only be in modes 5 or 6
   *                              fixed null mode crash ?
-Line 35
+Line 43
   *                              motion search precision = 0 now effective in 2-pass
   *                              modulated quantization
   *                              added DX50 fourcc
-  *      01.12.2001      inital version; (c)2001 peter ross <suxen_drol@hotmail.com>
+  *      01.12.2001      inital version; (c)2001 peter ross <pross@xvid.org>
   *
   *************************************************************************/
-Line 43
+Line 51
  #include <vfw.h>
  #include "codec.h"
- #include <math.h>       // fabs()
+ #include "2pass.h"
  int pmvfast_presets[7] = {
-, PMV_QUICKSTOP16, PMV_EARLYSTOP16, PMV_EARLYSTOP16 | PMV_EARLYSTOP8,
+, PMV_QUICKSTOP16, 0, 0,
-         PMV_EARLYSTOP16 | PMV_HALFPELREFINE16 | PMV_EARLYSTOP8 | PMV_HALFPELDIAMOND8,
+| PMV_HALFPELREFINE16 | PMV_HALFPELDIAMOND8,
-         PMV_EARLYSTOP16 | PMV_HALFPELREFINE16 | PMV_EARLYSTOP8 | PMV_HALFPELDIAMOND8,
+| PMV_HALFPELREFINE16 | PMV_HALFPELDIAMOND8 |
-         PMV_EARLYSTOP16 | PMV_HALFPELREFINE16 | PMV_EXTSEARCH16 |
+         PMV_ADVANCEDDIAMOND16, PMV_HALFPELREFINE16 | PMV_EXTSEARCH16 |
-         PMV_EARLYSTOP8 | PMV_HALFPELREFINE8 | PMV_HALFPELDIAMOND8
+         PMV_HALFPELREFINE8 | PMV_HALFPELDIAMOND8 | PMV_USESQUARES16
  };
  /*      return xvid compatbile colorspace,
-Line 59
+Line 67
  int get_colorspace(BITMAPINFOHEADER * hdr)
  {
-         if (hdr->biHeight < 0)
+         /* rgb only: negative height specifies top down image */
-         {
+         int rgb_flip = (hdr->biHeight < 0 ? 0 : XVID_CSP_VFLIP);
-                 DEBUGERR("colorspace: inverted input format not supported");
-                 return XVID_CSP_NULL;
-         }
          switch(hdr->biCompression)
          {
-Line 71
+Line 76
                  if (hdr->biBitCount == 16)
                  {
                          DEBUG("RGB16 (RGB555)");
-                         return XVID_CSP_VFLIP | XVID_CSP_RGB555;
+                         return rgb_flip | XVID_CSP_RGB555;
                  }
                  if (hdr->biBitCount == 24)
                  {
                          DEBUG("RGB24");
-                         return XVID_CSP_VFLIP | XVID_CSP_RGB24;
+                         return rgb_flip | XVID_CSP_RGB24;
                  }
                  if (hdr->biBitCount == 32)
                  {
                          DEBUG("RGB32");
-                         return XVID_CSP_VFLIP | XVID_CSP_RGB32;
+                         return rgb_flip | XVID_CSP_RGB32;
                  }
-                 DEBUG1("BI_RGB unsupported", hdr->biBitCount);
+                 DEBUG1("unsupported BI_RGB biBitCount", hdr->biBitCount);
                  return XVID_CSP_NULL;
- // how do these work in BITMAPINFOHEADER ???
+         case BI_BITFIELDS :
- /*      case BI_BITFIELDS :
+                 if (hdr->biSize >= sizeof(BITMAPV4HEADER))
-                 if (hdr->biBitCount == 16
+                 {
-                 if(hdr->biBitCount == 16 &&
+                         BITMAPV4HEADER * hdr4 = (BITMAPV4HEADER *)hdr;
-                         hdr->bV4RedMask == 0x7c00 &&
-                         hdr->bV4GreenMask == 0x3e0 &&
+                         if (hdr4->bV4BitCount == 16 &&
-                         hdr->bV4BlueMask == 0x1f)
+                                 hdr4->bV4RedMask == 0x7c00 &&
+                                 hdr4->bV4GreenMask == 0x3e0 &&
+                                 hdr4->bV4BlueMask == 0x1f)
                  {
                          DEBUG("RGB555");
-                         return XVID_CSP_VFLIP | XVID_CSP_RGB555;
+                                 return rgb_flip | XVID_CSP_RGB555;
                  }
-                 if(hdr->bV4BitCount == 16 &&
-                         hdr->bV4RedMask == 0xf800 &&
+                         if(hdr4->bV4BitCount == 16 &&
-                         hdr->bV4GreenMask == 0x7e0 &&
+                                 hdr4->bV4RedMask == 0xf800 &&
-                         hdr->bV4BlueMask == 0x1f)
+                                 hdr4->bV4GreenMask == 0x7e0 &&
+                                 hdr4->bV4BlueMask == 0x1f)
                  {
                          DEBUG("RGB565");
-                         return XVID_CSP_VFLIP | XVID_CSP_RGB565;
+                                 return rgb_flip | XVID_CSP_RGB565;
                  }
-                 DEBUG1("BI_FIELDS unsupported", hdr->bV4BitCount);
+                         DEBUG("unsupported BI_BITFIELDS mode");
                  return XVID_CSP_NULL;
- */
+                 }
+                 DEBUG("unsupported BI_BITFIELDS/BITMAPHEADER combination");
+                 return XVID_CSP_NULL;
          case FOURCC_I420:
          case FOURCC_IYUV:
                  DEBUG("IYUY");
-Line 121
+Line 133
          case FOURCC_YUYV :
          case FOURCC_YUY2 :
-         case FOURCC_V422 :
                  DEBUG("YUY2");
                  return XVID_CSP_YUY2;
-Line 133
+Line 144
                  DEBUG("UYVY");
                  return XVID_CSP_UYVY;
-         }
+         default :
-         DEBUGFOURCC("colorspace: unknown", hdr->biCompression);
+                 DEBUGFOURCC("unsupported colorspace", hdr->biCompression);
          return XVID_CSP_NULL;
  }
+ }
  /* compressor */
-Line 160
+Line 172
          }
          if (inhdr->biWidth != outhdr->biWidth || inhdr->biHeight != outhdr->biHeight ||
-                 (outhdr->biCompression != FOURCC_XVID && outhdr->biCompression != FOURCC_DIVX))
+                 (outhdr->biCompression != FOURCC_XVID && outhdr->biCompression != FOURCC_DIVX && outhdr->biCompression != FOURCC_DX50))
          {
                  return ICERR_BADFORMAT;
          }
-Line 186
+Line 198
          memcpy(outhdr, inhdr, sizeof(BITMAPINFOHEADER));
          outhdr->biSize = sizeof(BITMAPINFOHEADER);
-         outhdr->biBitCount = 24;  // or 16
          outhdr->biSizeImage = compress_get_size(codec, lpbiInput, lpbiOutput);
          outhdr->biXPelsPerMeter = 0;
          outhdr->biYPelsPerMeter = 0;
-Line 212
+Line 223
  LRESULT compress_get_size(CODEC * codec, BITMAPINFO * lpbiInput, BITMAPINFO * lpbiOutput)
  {
-         return lpbiOutput->bmiHeader.biWidth * lpbiOutput->bmiHeader.biHeight * 3;
+         return 2 * lpbiOutput->bmiHeader.biWidth * lpbiOutput->bmiHeader.biHeight * 3;
  }
-Line 233
+Line 244
          switch (codec->config.mode)
          {
          case DLG_MODE_CBR :
-                 param.bitrate = codec->config.bitrate;
+                 param.rc_bitrate = codec->config.rc_bitrate;
-                 param.rc_buffersize = codec->config.rc_buffersize;
+                 param.rc_reaction_delay_factor = codec->config.rc_reaction_delay_factor;
+                 param.rc_averaging_period = codec->config.rc_averaging_period;
+                 param.rc_buffer = codec->config.rc_buffer;
                  break;
          case DLG_MODE_VBR_QUAL :
                  codec->config.fquant = 0;
-                 param.bitrate = 0;
+                 param.rc_bitrate = 0;
                  break;
          case DLG_MODE_VBR_QUANT :
                  codec->config.fquant = (float) codec->config.quant;
-                 param.bitrate = 0;
+                 param.rc_bitrate = 0;
                  break;
          case DLG_MODE_2PASS_1 :
          case DLG_MODE_2PASS_2_INT :
          case DLG_MODE_2PASS_2_EXT :
-                 param.bitrate = 0;
+                 param.rc_bitrate = 0;
+                 codec->twopass.max_framesize = (int)((double)codec->config.twopass_max_bitrate / 8.0 / ((double)codec->fbase / (double)codec->fincr));
                  break;
          case DLG_MODE_NULL :
-Line 276
+Line 290
          param.fincr = codec->fincr;
          param.fbase = codec->fbase;
-         param.rc_buffersize = codec->config.rc_buffersize;
          param.min_quantizer = codec->config.min_pquant;
          param.max_quantizer = codec->config.max_pquant;
          param.max_key_interval = codec->config.max_key_interval;
+ #ifdef _SMP
+         param.num_threads = codec->config.num_threads;
+ #endif
+         param.global = 0;
+         if (codec->config.packed) param.global |= XVID_GLOBAL_PACKED;
+         if (codec->config.dx50bvop) param.global |= XVID_GLOBAL_DX50BVOP;
+         if (codec->config.debug) param.global |= XVID_GLOBAL_DEBUG;
+         if (codec->config.reduced_resolution) param.global |= XVID_GLOBAL_REDUCED;
+         param.max_bframes = codec->config.max_bframes;
+         param.bquant_ratio = codec->config.bquant_ratio;
+         param.bquant_offset = codec->config.bquant_offset;
+         param.frame_drop_ratio = codec->config.frame_drop_ratio;
          switch(xvid_encore(0, XVID_ENC_CREATE, &param, NULL))
          {
          case XVID_ERR_FAIL :
-Line 298
+Line 324
          codec->framenum = 0;
          codec->keyspacing = 0;
-         codec->twopass.stats1 = codec->twopass.stats2 = INVALID_HANDLE_VALUE;
+         codec->twopass.hints = codec->twopass.stats1 = codec->twopass.stats2 = INVALID_HANDLE_VALUE;
+         codec->twopass.hintstream = NULL;
          return ICERR_OK;
  }
-Line 309
+Line 336
          if (codec->ehandle != NULL)
          {
                  xvid_encore(codec->ehandle, XVID_ENC_DESTROY, NULL, NULL);
+                 if (codec->twopass.hints != INVALID_HANDLE_VALUE)
+                 {
+                         CloseHandle(codec->twopass.hints);
+                 }
                  if (codec->twopass.stats1 != INVALID_HANDLE_VALUE)
                  {
                          CloseHandle(codec->twopass.stats1);
-Line 317
+Line 349
                  {
                          CloseHandle(codec->twopass.stats2);
                  }
+                 if (codec->twopass.hintstream != NULL)
+                 {
+                         free(codec->twopass.hintstream);
+                 }
                  codec->ehandle = NULL;
+                 codec_2pass_finish(codec);
          }
          return ICERR_OK;
-Line 345
+Line 384
          frame.intra = -1;
          frame.general |= XVID_HALFPEL;
+ //      frame.general |= XVID_ME_EPZS;
+         frame.general |= XVID_HQACPRED;
          if(codec->config.motion_search > 4)
                  frame.general |= XVID_INTER4V;
-         if(((codec->config.mode == DLG_MODE_2PASS_1) ? 0 : codec->config.lum_masking) == 1)
+         if (codec->config.lum_masking)
                  frame.general |= XVID_LUMIMASKING;
-         frame.motion = pmvfast_presets[codec->config.motion_search];
+         if (codec->config.interlacing)
+                 frame.general |= XVID_INTERLACING;
+         if (codec->config.qpel) {
+                 frame.general |= XVID_QUARTERPEL;
+                 frame.motion |= PMV_QUARTERPELREFINE16 | PMV_QUARTERPELREFINE8;
+         }
+         if (codec->config.gmc)
+                 frame.general |= XVID_GMC;
+         if (codec->config.chromame)
+                 frame.motion |= PMV_CHROMA16 + PMV_CHROMA8;
+         if (codec->config.reduced_resolution)
+                 frame.general |= XVID_REDUCED;
+         if (codec->config.chroma_opt)
+                 frame.general |= XVID_CHROMAOPT;
+ // added by koepi for credits greyscale
+         check_greyscale_mode(&codec->config, &frame, codec->framenum);
+ // end of koepi's addition
+ // fix 1pass modes/hinted MV by koepi
+         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))
+         {
+                 codec->config.hinted_me = 0;
+         }
+ // end of ugly hack
+         if (codec->config.hinted_me && codec->config.mode == DLG_MODE_2PASS_1)
+         {
+                 frame.hint.hintstream = codec->twopass.hintstream;
+                 frame.hint.rawhints = 0;
+                 frame.general |= XVID_HINTEDME_GET;
+         }
+         else if (codec->config.hinted_me && (codec->config.mode == DLG_MODE_2PASS_2_EXT || codec->config.mode == DLG_MODE_2PASS_2_INT))
+         {
+                 DWORD read;
+                 DWORD blocksize;
+                 frame.hint.hintstream = codec->twopass.hintstream;
+                 frame.hint.rawhints = 0;
+                 frame.general |= XVID_HINTEDME_SET;
+                 if (codec->twopass.hints == INVALID_HANDLE_VALUE)
+                 {
+                         codec->twopass.hints = CreateFile(codec->config.hintfile, GENERIC_READ, 0, 0, OPEN_EXISTING, 0, 0);
+                         if (codec->twopass.hints == INVALID_HANDLE_VALUE)
+                         {
+                                 DEBUGERR("couldn't open hints file");
+                                 return ICERR_ERROR;
+                         }
+                 }
+                 if (!ReadFile(codec->twopass.hints, &blocksize, sizeof(DWORD), &read, 0) || read != sizeof(DWORD) ||
+                         !ReadFile(codec->twopass.hints, frame.hint.hintstream, blocksize, &read, 0) || read != blocksize)
+                 {
+                         DEBUGERR("couldn't read from hints file");
+                         return ICERR_ERROR;
+                 }
+         }
+         frame.motion |= pmvfast_presets[codec->config.motion_search];
+         switch (codec->config.vhq_mode)
+         {
+         case VHQ_MODE_DECISION :
+                 frame.general |= XVID_MODEDECISION_BITS;
+                 break;
+         case VHQ_LIMITED_SEARCH :
+                 frame.general |= XVID_MODEDECISION_BITS;
+                 frame.motion |= HALFPELREFINE16_BITS;
+                 frame.motion |= QUARTERPELREFINE16_BITS;
+                 break;
+         case VHQ_MEDIUM_SEARCH :
+                 frame.general |= XVID_MODEDECISION_BITS;
+                 frame.motion |= HALFPELREFINE16_BITS;
+                 frame.motion |= HALFPELREFINE8_BITS;
+                 frame.motion |= QUARTERPELREFINE16_BITS;
+                 frame.motion |= QUARTERPELREFINE8_BITS;
+                 frame.motion |= CHECKPREDICTION_BITS;
+                 break;
+         case VHQ_WIDE_SEARCH :
+                 frame.general |= XVID_MODEDECISION_BITS;
+                 frame.motion |= HALFPELREFINE16_BITS;
+                 frame.motion |= HALFPELREFINE8_BITS;
+                 frame.motion |= QUARTERPELREFINE16_BITS;
+                 frame.motion |= QUARTERPELREFINE8_BITS;
+                 frame.motion |= CHECKPREDICTION_BITS;
+                 frame.motion |= EXTSEARCH_BITS;
+                 break;
+         default :
+                 break;
+         }
          frame.image = icc->lpInput;
+         frame.stride = (((icc->lpbiInput->biWidth * icc->lpbiInput->biBitCount) + 31) & ~31) >> 3;
          if ((frame.colorspace = get_colorspace(inhdr)) == XVID_CSP_NULL)
                  return ICERR_BADFORMAT;
+         if (frame.colorspace == XVID_CSP_I420 || frame.colorspace == XVID_CSP_YV12)
+                 frame.stride = (frame.stride*2)/3;
          frame.bitstream = icc->lpOutput;
          frame.length = icc->lpbiOutput->biSizeImage;
-Line 429
+Line 575
          {
                  frame.intra = 1;
          }
-         else if ((codec->keyspacing < codec->config.min_key_interval && codec->framenum) &&
+         else if (codec->keyspacing < codec->config.min_key_interval && codec->framenum)
-                 (codec->config.mode == DLG_MODE_2PASS_1))
          {
                  DEBUG("current frame forced to p-frame");
                  frame.intra = 0;
          }
+         frame.bquant = 0;
+ //      OutputDebugString(" ");
          switch (xvid_encore(codec->ehandle, XVID_ENC_ENCODE, &frame, &stats))
          {
          case XVID_ERR_FAIL :
-Line 448
+Line 596
                  return ICERR_BADFORMAT;
          }
-         if (frame.intra)
+         if (frame.intra==1)
          {
                  codec->keyspacing = 0;
                  *icc->lpdwFlags = AVIIF_KEYFRAME;
-Line 457
+Line 605
          {
                  *icc->lpdwFlags = 0;
          }
+         if (frame.length == 0) { frame.length = 1; *((unsigned char*)frame.bitstream) = 0x7f; }
          outhdr->biSizeImage = frame.length;
-Line 465
+Line 614
                  outhdr->biSizeImage = 0;
          }
+         if (frame.general & XVID_HINTEDME_GET)
+         {
+                 DWORD wrote;
+                 DWORD blocksize = frame.hint.hintlength;
+                 if (codec->twopass.hints == INVALID_HANDLE_VALUE)
+                 {
+                         codec->twopass.hints = CreateFile(codec->config.hintfile, GENERIC_WRITE, 0, 0, CREATE_ALWAYS, 0, 0);
+                         if (codec->twopass.hints        == INVALID_HANDLE_VALUE)
+                         {
+                                 DEBUGERR("couldn't create hints file");
+                                 return ICERR_ERROR;
+                         }
+                 }
+                 if (!WriteFile(codec->twopass.hints, &frame.hint.hintlength, sizeof(int), &wrote, 0) || wrote != sizeof(int) ||
+                         !WriteFile(codec->twopass.hints, frame.hint.hintstream, blocksize, &wrote, 0) || wrote != blocksize)
+                 {
+                         DEBUGERR("couldn't write to hints file");
+                         return ICERR_ERROR;
+                 }
+         }
+ //quick fix for delayed frames
+ //      if (frame.intra != 5)
          codec_2pass_update(codec, &frame, &stats);
          ++codec->framenum;
-Line 487
+Line 660
                  return ICERR_ERROR;
          }
-         if (inhdr->biCompression != FOURCC_XVID && inhdr->biCompression != FOURCC_DIVX)
+         if (inhdr->biCompression != FOURCC_XVID && inhdr->biCompression != FOURCC_DIVX && inhdr->biCompression != FOURCC_DX50 && get_colorspace(inhdr) == XVID_CSP_NULL)
          {
                  return ICERR_BADFORMAT;
          }
-Line 519
+Line 692
                  return sizeof(BITMAPINFOHEADER);
          }
-         result = decompress_query(codec, lpbiInput, lpbiOutput);
+         /* --- yv12 --- */
+         if (get_colorspace(inhdr) != XVID_CSP_NULL) {
+                 memcpy(outhdr, inhdr, sizeof(BITMAPINFOHEADER));
+                 // XXX: should we set outhdr->biSize ??
+                 return ICERR_OK;
+         }
+         /* --- yv12 --- */
+         result = decompress_query(codec, lpbiInput, NULL);
          if (result != ICERR_OK)
          {
                  return result;
          }
-         memcpy(outhdr, inhdr, sizeof(BITMAPINFOHEADER));
          outhdr->biSize = sizeof(BITMAPINFOHEADER);
-         outhdr->biCompression = FOURCC_YUY2;
+         outhdr->biWidth = inhdr->biWidth;
+         outhdr->biHeight = inhdr->biHeight;
+         outhdr->biPlanes = 1;
+         outhdr->biBitCount = 24;
+         outhdr->biCompression = BI_RGB; /* sonic foundry vegas video v3 only supports BI_RGB */
          outhdr->biSizeImage = outhdr->biWidth * outhdr->biHeight * outhdr->biBitCount;
          outhdr->biXPelsPerMeter = 0;
          outhdr->biYPelsPerMeter = 0;
-Line 588
+Line 773
          frame.bitstream = icd->lpInput;
          frame.length = icd->lpbiInput->biSizeImage;
+         frame.general = XVID_DEC_LOWDELAY;      /* force low_delay_default mode */
+         if (codec->config.deblock_y)
+                 frame.general |= XVID_DEC_DEBLOCKY;
+         if (codec->config.deblock_uv)
+                 frame.general |= XVID_DEC_DEBLOCKUV;
          frame.image = icd->lpOutput;
-         frame.stride = icd->lpbiOutput->biWidth;
+         frame.stride = (((icd->lpbiOutput->biWidth * icd->lpbiOutput->biBitCount) + 31) & ~31) >> 3;
+         /* --- yv12 --- */
+         if (icd->lpbiInput->biCompression != FOURCC_XVID &&
+                  icd->lpbiInput->biCompression != FOURCC_DIVX &&
+                  icd->lpbiInput->biCompression != FOURCC_DX50)
+         {
+                 XVID_INIT_CONVERTINFO convert;
+                 DEBUGFOURCC("input", icd->lpbiInput->biCompression);
+                 DEBUGFOURCC("output", icd->lpbiOutput->biCompression);
+                 convert.input.colorspace = get_colorspace(icd->lpbiInput);
+                 convert.input.y = icd->lpInput;
+                 convert.input.y_stride = (((icd->lpbiInput->biWidth *icd->lpbiInput->biBitCount) + 31) & ~31) >> 3;
+                 if (convert.input.colorspace == XVID_CSP_I420 || convert.input.colorspace == XVID_CSP_YV12)
+                         convert.input.y_stride = (convert.input.y_stride*2)/3;
+                 convert.output.colorspace = get_colorspace(icd->lpbiOutput);
+                 convert.output.y = icd->lpOutput;
+                 convert.output.y_stride = (((icd->lpbiOutput->biWidth *icd->lpbiOutput->biBitCount) + 31) & ~31) >> 3;
+                 if (convert.output.colorspace == XVID_CSP_I420 || convert.output.colorspace == XVID_CSP_YV12)
+                         convert.output.y_stride = (convert.output.y_stride*2)/3;
+                 convert.width = icd->lpbiInput->biWidth;
+                 convert.height = icd->lpbiInput->biHeight;
+                 convert.interlacing = 0;
+                 if (convert.input.colorspace == XVID_CSP_NULL ||
+                         convert.output.colorspace == XVID_CSP_NULL ||
+                         xvid_init(NULL, XVID_INIT_CONVERT, &convert, NULL) != XVID_ERR_OK)
+                 {
+                          return ICERR_BADFORMAT;
+                 }
+                 return ICERR_OK;
+         }
+         /* --- yv12 --- */
-         if (~((icd->dwFlags & ICDECOMPRESS_HURRYUP) | (icd->dwFlags & ICDECOMPRESS_UPDATE)))
+         if (~((icd->dwFlags & ICDECOMPRESS_HURRYUP) | (icd->dwFlags & ICDECOMPRESS_UPDATE) | (icd->dwFlags & ICDECOMPRESS_PREROLL)))
          {
                  if ((frame.colorspace = get_colorspace(icd->lpbiOutput)) == XVID_CSP_NULL)
                  {
-Line 604
+Line 828
                  frame.colorspace = XVID_CSP_NULL;
          }
+         if (frame.colorspace == XVID_CSP_I420 || frame.colorspace == XVID_CSP_YV12)
+                 frame.stride = (frame.stride*2)/3;
          switch (xvid_decore(codec->dhandle, XVID_DEC_DECODE, &frame, NULL))
          {
          case XVID_ERR_FAIL :
-Line 619
+Line 846
          return ICERR_OK;
  }
- int codec_2pass_init(CODEC* codec)
+ int codec_get_quant(CODEC* codec, XVID_ENC_FRAME* frame)
  {
-         TWOPASS *twopass = &codec->twopass;
-         DWORD version = -20;
-         DWORD read, wrote;
-         int     frames = 0, credits_frames = 0, i_frames = 0;
-         __int64 total = 0, i_total = 0, i_boost_total = 0, start = 0, end = 0, start_curved = 0, end_curved = 0;
-         __int64 desired = codec->config.desired_size * 1024;
-         double total1 = 0.0;
-         double total2 = 0.0;
          switch (codec->config.mode)
          {
-         case DLG_MODE_2PASS_1 :
+         case DLG_MODE_VBR_QUAL :
-                 twopass->stats1 = CreateFile(codec->config.stats1, GENERIC_WRITE, FILE_SHARE_READ, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
+                 if (codec_is_in_credits(&codec->config, codec->framenum))
-                 if (twopass->stats1 == INVALID_HANDLE_VALUE)
                  {
-                         DEBUGERR("2pass init error - couldn't create stats1");
+ // added by koepi for credits greyscale
-                         return ICERR_ERROR;
-                 }
+                         check_greyscale_mode(&codec->config, frame, codec->framenum);
-                 if (WriteFile(twopass->stats1, &version, sizeof(DWORD), &wrote, 0) == 0 || wrote != sizeof(DWORD))
+ // end of koepi's addition
+                         switch (codec->config.credits_mode)
                  {
-                         CloseHandle(twopass->stats1);
+                         case CREDITS_MODE_RATE :
-                         twopass->stats1 = INVALID_HANDLE_VALUE;
+                                 frame->quant = codec_get_vbr_quant(&codec->config, codec->config.quality * codec->config.credits_rate / 100);
-                         DEBUGERR("2pass init error - couldn't write to stats1");
-                         return ICERR_ERROR;
-                 }
                  break;
-         case DLG_MODE_2PASS_2_INT :
+                         case CREDITS_MODE_QUANT :
-         case DLG_MODE_2PASS_2_EXT :
+                                 frame->quant = codec->config.credits_quant_p;
-                 twopass->stats1 = CreateFile(codec->config.stats1, GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
+                                 break;
-                 if (twopass->stats1 == INVALID_HANDLE_VALUE)
-                 {
+                         default :
-                         DEBUGERR("2pass init error - couldn't open stats1");
+                                 DEBUGERR("Can't use credits size mode in quality mode");
                          return ICERR_ERROR;
                  }
-                 if (ReadFile(twopass->stats1, &version, sizeof(DWORD), &read, 0) == 0 || read != sizeof(DWORD))
-                 {
-                         CloseHandle(twopass->stats1);
-                         twopass->stats1 = INVALID_HANDLE_VALUE;
-                         DEBUGERR("2pass init error - couldn't read from stats1");
-                         return ICERR_ERROR;
                  }
-                 if (version != -20)
+                 else
                  {
-                         CloseHandle(twopass->stats1);
+ // added by koepi for credits greyscale
-                         twopass->stats1 = INVALID_HANDLE_VALUE;
-                         DEBUGERR("2pass init error - wrong .stats version");
-                         return ICERR_ERROR;
-                 }
-                 if (codec->config.mode == DLG_MODE_2PASS_2_EXT)
+                         check_greyscale_mode(&codec->config, frame, codec->framenum);
-                 {
-                         if (twopass->stats2 != INVALID_HANDLE_VALUE)
-                         {
-                                 CloseHandle(twopass->stats2);
-                         }
-                         twopass->stats2 = CreateFile(codec->config.stats2, GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
+ // end of koepi's addition
-                         if (twopass->stats2 == INVALID_HANDLE_VALUE)
+                         frame->quant = codec_get_vbr_quant(&codec->config, codec->config.quality);
-                         {
-                                 CloseHandle(twopass->stats1);
-                                 twopass->stats1 = INVALID_HANDLE_VALUE;
-                                 DEBUGERR("2pass init error - couldn't open stats2");
-                                 return ICERR_ERROR;
-                         }
-                         if (ReadFile(twopass->stats2, &version, sizeof(DWORD), &read, 0) == 0 || read != sizeof(DWORD))
-                         {
-                                 CloseHandle(twopass->stats1);
-                                 twopass->stats1 = INVALID_HANDLE_VALUE;
-                                 CloseHandle(twopass->stats2);
-                                 twopass->stats2 = INVALID_HANDLE_VALUE;
-                                 DEBUGERR("2pass init error - couldn't read from stats2");
-                                 return ICERR_ERROR;
-                         }
-                         if (version != -20)
-                         {
-                                 CloseHandle(twopass->stats1);
-                                 twopass->stats1 = INVALID_HANDLE_VALUE;
-                                 CloseHandle(twopass->stats2);
-                                 twopass->stats2 = INVALID_HANDLE_VALUE;
-                                 DEBUGERR("2pass init error - wrong .stats version");
-                                 return ICERR_ERROR;
                          }
+                 return ICERR_OK;
-                         while (1)
+         case DLG_MODE_VBR_QUANT :
-                         {
+                 if (codec_is_in_credits(&codec->config, codec->framenum))
-                                 if (!ReadFile(twopass->stats1, &twopass->nns1, sizeof(NNSTATS), &read, NULL) || read != sizeof(NNSTATS) ||
-                                         !ReadFile(twopass->stats2, &twopass->nns2, sizeof(NNSTATS), &read, NULL) || read != sizeof(NNSTATS))
                                  {
-                                         DWORD err = GetLastError();
+ // added by koepi for credits greyscale
+                         check_greyscale_mode(&codec->config, frame, codec->framenum);
-                                         if (err == ERROR_HANDLE_EOF || err == ERROR_SUCCESS)
+ // end of koepi's addition
+                         switch (codec->config.credits_mode)
                                          {
+                         case CREDITS_MODE_RATE :
+                                 frame->quant =
+                                         codec->config.max_pquant -
+                                         ((codec->config.max_pquant - codec->config.quant) * codec->config.credits_rate / 100);
                                                  break;
-                                         }
-                                         else
+                         case CREDITS_MODE_QUANT :
-                                         {
+                                 frame->quant = codec->config.credits_quant_p;
-                                                 CloseHandle(twopass->stats1);
+                                 break;
-                                                 CloseHandle(twopass->stats2);
-                                                 twopass->stats1 = INVALID_HANDLE_VALUE;
+                         default :
-                                                 twopass->stats2 = INVALID_HANDLE_VALUE;
+                                 DEBUGERR("Can't use credits size mode in quantizer mode");
-                                                 DEBUGERR("2pass init error - incomplete stats1/stats2 record?");
                                                  return ICERR_ERROR;
                                          }
                                  }
+                 else
-                                 if (!codec_is_in_credits(&codec->config, frames))
-                                 {
-                                         if (twopass->nns1.quant & NNSTATS_KEYFRAME)
                                          {
-                                                 i_boost_total = twopass->nns2.bytes * codec->config.keyframe_boost / 100;
+ // added by koepi for credits greyscale
-                                                 i_total += twopass->nns2.bytes;
-                                                 ++i_frames;
-                                         }
-                                         total += twopass->nns2.bytes;
+                         check_greyscale_mode(&codec->config, frame, codec->framenum);
-                                 }
-                                 else
-                                         ++credits_frames;
-                                 ++frames;
+ // end of koepi's addition
+                         frame->quant = codec->config.quant;
                          }
+                 return ICERR_OK;
-                         twopass->movie_curve = ((float)(total + i_boost_total) / total);
+         case DLG_MODE_2PASS_1 :
-                         twopass->average_frame = ((double)(total - i_total) / (frames - credits_frames - i_frames) / twopass->movie_curve);
+ // added by koepi for credits greyscale
-                         SetFilePointer(twopass->stats1, sizeof(DWORD), 0, FILE_BEGIN);
+                 check_greyscale_mode(&codec->config, frame, codec->framenum);
-                         SetFilePointer(twopass->stats2, sizeof(DWORD), 0, FILE_BEGIN);
-                         // perform prepass to compensate for over/undersizing
+ // end of koepi's addition
-                         frames = 0;
-                         if (codec->config.use_alt_curve)
+                 if (codec->config.credits_mode == CREDITS_MODE_QUANT)
-                         {
-                                 twopass->alt_curve_low = twopass->average_frame - twopass->average_frame * (double)codec->config.alt_curve_low_dist / 100.0;
-                                 twopass->alt_curve_low_diff = twopass->average_frame - twopass->alt_curve_low;
-                                 twopass->alt_curve_high = twopass->average_frame + twopass->average_frame * (double)codec->config.alt_curve_high_dist / 100.0;
-                                 twopass->alt_curve_high_diff = twopass->alt_curve_high - twopass->average_frame;
-                                 if (codec->config.alt_curve_use_auto)
                                  {
-                                         if (twopass->movie_curve > 1.0f)
+                         if (codec_is_in_credits(&codec->config, codec->framenum))
                                          {
-                                                 codec->config.alt_curve_min_rel_qual = (int)(100.0 - (100.0 - 100.0 / twopass->movie_curve) * (double)codec->config.alt_curve_auto_str / 100.0);
+                                 frame->quant = codec->config.credits_quant_p;
-                                                 if (codec->config.alt_curve_min_rel_qual < 20)
-                                                         codec->config.alt_curve_min_rel_qual = 20;
                                          }
                                          else
-                                                 codec->config.alt_curve_min_rel_qual = 100;
-                                 }
-                                 twopass->alt_curve_mid_qual = (1.0 + (double)codec->config.alt_curve_min_rel_qual / 100.0) / 2.0;
-                                 twopass->alt_curve_qual_dev = 1.0 - twopass->alt_curve_mid_qual;
-                                 if (codec->config.alt_curve_low_dist > 100)
-                                 {
-                                         switch(codec->config.alt_curve_type)
-                                         {
-                                         case 2: // Sine Curve (high aggressiveness)
-                                                 twopass->alt_curve_qual_dev *= 2.0 / (1.0 +
-                                                         sin(DEG2RAD * (twopass->average_frame * 90.0 / twopass->alt_curve_low_diff)));
-                                                 twopass->alt_curve_mid_qual = 1.0 - twopass->alt_curve_qual_dev *
-                                                         sin(DEG2RAD * (twopass->average_frame * 90.0 / twopass->alt_curve_low_diff));
-                                                 break;
-                                         case 1: // Linear (medium aggressiveness)
-                                                 twopass->alt_curve_qual_dev *= 2.0 / (1.0 +
-                                                         twopass->average_frame / twopass->alt_curve_low_diff);
-                                                 twopass->alt_curve_mid_qual = 1.0 - twopass->alt_curve_qual_dev *
-                                                         twopass->average_frame / twopass->alt_curve_low_diff;
-                                                 break;
-                                         case 0: // Cosine Curve (low aggressiveness)
-                                                 twopass->alt_curve_qual_dev *= 2.0 / (1.0 +
-                                                         (1.0 - cos(DEG2RAD * (twopass->average_frame * 90.0 / twopass->alt_curve_low_diff))));
-                                                 twopass->alt_curve_mid_qual = 1.0 - twopass->alt_curve_qual_dev *
-                                                         (1.0 - cos(DEG2RAD * (twopass->average_frame * 90.0 / twopass->alt_curve_low_diff)));
-                                         }
-                                 }
-                         }
-                         while (1)
-                         {
-                                 if (!ReadFile(twopass->stats1, &twopass->nns1, sizeof(NNSTATS), &read, NULL) || read != sizeof(NNSTATS) ||
-                                         !ReadFile(twopass->stats2, &twopass->nns2, sizeof(NNSTATS), &read, NULL) || read != sizeof(NNSTATS))
                                  {
-                                         DWORD err = GetLastError();
+                                 frame->quant = 2;
+                         }
-                                         if (err == ERROR_HANDLE_EOF || err == ERROR_SUCCESS)
-                                         {
-                                                 break;
                                          }
                                          else
                                          {
-                                                 CloseHandle(twopass->stats1);
+                         frame->quant = 2;
-                                                 CloseHandle(twopass->stats2);
+                 }
-                                                 twopass->stats1 = INVALID_HANDLE_VALUE;
+                 return ICERR_OK;
-                                                 twopass->stats2 = INVALID_HANDLE_VALUE;
-                                                 DEBUGERR("2pass init error - incomplete stats1/stats2 record?");
+         default:
+                 DEBUGERR("get quant: invalid mode");
                                                  return ICERR_ERROR;
                                          }
                                  }
-                                 if (!codec_is_in_credits(&codec->config, frames) &&
-                                         !(twopass->nns1.quant & NNSTATS_KEYFRAME))
-                                 {
-                                         double dbytes = twopass->nns2.bytes / twopass->movie_curve;
-                                         total1 += dbytes;
-                                         if (codec->config.use_alt_curve)
+ int codec_is_in_credits(CONFIG* config, int framenum)
-                                         {
-                                                 if (dbytes > twopass->average_frame)
                                                  {
-                                                         if (dbytes >= twopass->alt_curve_high)
+         if (config->credits_start)
-                                                                 total2 += dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev);
-                                                         else
                                                          {
-                                                                 switch(codec->config.alt_curve_type)
+                 if (framenum >= config->credits_start_begin &&
+                         framenum <= config->credits_start_end)
                                                                  {
-                                                                 case 2:
+                         return CREDITS_START;
-                                                                 total2 += dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev *
-                                                                         sin(DEG2RAD * ((dbytes - twopass->average_frame) * 90.0 / twopass->alt_curve_high_diff)));
-                                                                         break;
-                                                                 case 1:
-                                                                 total2 += dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev *
-                                                                         (dbytes - twopass->average_frame) / twopass->alt_curve_high_diff);
-                                                                         break;
-                                                                 case 0:
-                                                                 total2 += dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev *
-                                                                         (1.0 - cos(DEG2RAD * ((dbytes - twopass->average_frame) * 90.0 / twopass->alt_curve_high_diff))));
-                                                                 }
                                                          }
                                                  }
-                                                 else
-                                                 {
+         if (config->credits_end)
-                                                         if (dbytes <= twopass->alt_curve_low)
-                                                                 total2 += dbytes;
-                                                         else
                                                          {
-                                                                 switch(codec->config.alt_curve_type)
+                 if (framenum >= config->credits_end_begin &&
+                         framenum <= config->credits_end_end)
                                                                  {
-                                                                 case 2:
+                         return CREDITS_END;
-                                                                 total2 += dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev *
-                                                                         sin(DEG2RAD * ((dbytes - twopass->average_frame) * 90.0 / twopass->alt_curve_low_diff)));
-                                                                         break;
-                                                                 case 1:
-                                                                 total2 += dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev *
-                                                                         (dbytes - twopass->average_frame) / twopass->alt_curve_low_diff);
-                                                                         break;
-                                                                 case 0:
-                                                                 total2 += dbytes * (twopass->alt_curve_mid_qual + twopass->alt_curve_qual_dev *
-                                                                         (1.0 - cos(DEG2RAD * ((dbytes - twopass->average_frame) * 90.0 / twopass->alt_curve_low_diff))));
-                                                                 }
                                                          }
                                                  }
+         return 0;
                                          }
-                                         else
+ int codec_get_vbr_quant(CONFIG* config, int quality)
                                          {
-                                                 if (dbytes > twopass->average_frame)
+         static float fquant_running = 0;
+         static int my_quality = -1;
+         int     quant;
+         // if quality changes, recalculate fquant (credits)
+         if (quality != my_quality)
                                                  {
-                                                         total2 += ((double)dbytes + (twopass->average_frame - dbytes) *
+                 config->fquant = 0;
-                                                                 codec->config.curve_compression_high / 100.0);
                                                  }
-                                                 else
+         my_quality = quality;
+         // desired quantiser = (maxQ-minQ)/100 * (100-qual) + minQ
+         if (!config->fquant)
                                                  {
-                                                         total2 += ((double)dbytes + (twopass->average_frame - dbytes) *
+                 config->fquant =
-                                                                 codec->config.curve_compression_low / 100.0);
+                         ((float) (config->max_pquant - config->min_pquant) / 100) *
+                         (100 - quality) +
+                         (float) config->min_pquant;
+                 fquant_running = config->fquant;
                                                  }
+         if (fquant_running < config->min_pquant)
+         {
+                 fquant_running = (float) config->min_pquant;
                                          }
+         else if(fquant_running > config->max_pquant)
+         {
+                 fquant_running = (float) config->max_pquant;
                                  }
-                                 ++frames;
+         quant = (int) fquant_running;
+         // add error between fquant and quant to fquant_running
+         fquant_running += config->fquant - quant;
+         return quant;
                          }
-                         twopass->curve_comp_scale = total1 / total2;
+ // added by koepi for credits greyscale
+ int check_greyscale_mode(CONFIG* config, XVID_ENC_FRAME* frame, int framenum)
-                         if (!codec->config.use_alt_curve)
                          {
-                                 int asymmetric_average_frame;
-                                 char s[100];
-                                 asymmetric_average_frame = (int)(twopass->average_frame * twopass->curve_comp_scale);
+         if ((codec_is_in_credits(config, framenum)) && (config->mode!=DLG_MODE_CBR))
-                                 wsprintf(s, "middle frame size for asymmetric curve compression: %i", asymmetric_average_frame);
-                                 DEBUG2P(s);
-                         }
-                         SetFilePointer(twopass->stats1, sizeof(DWORD), 0, FILE_BEGIN);
-                         SetFilePointer(twopass->stats2, sizeof(DWORD), 0, FILE_BEGIN);
-                 }
-                 else    // DLG_MODE_2PASS_2_INT
-                 {
-                         while (1)
-                         {
-                                 if (!ReadFile(twopass->stats1, &twopass->nns1, sizeof(NNSTATS), &read, NULL) || read != sizeof(NNSTATS))
                                  {
-                                         DWORD err = GetLastError();
-                                         if (err == ERROR_HANDLE_EOF || err == ERROR_SUCCESS)
-                                         {
-                                                 break;
-                                         }
-                                         else
-                                         {
-                                                 CloseHandle(twopass->stats1);
-                                                 twopass->stats1 = INVALID_HANDLE_VALUE;
-                                                 DEBUGERR("2pass init error - incomplete stats2 record?");
-                                                 return ICERR_ERROR;
-                                         }
-                                 }
-                                 if (codec_is_in_credits(&codec->config, frames) == CREDITS_START)
-                                 {
-                                         start += twopass->nns1.bytes;
-                                         ++credits_frames;
-                                 }
-                                 else if (codec_is_in_credits(&codec->config, frames) == CREDITS_END)
-                                 {
-                                         end += twopass->nns1.bytes;
-                                         ++credits_frames;
-                                 }
-                                 else if (twopass->nns1.quant & NNSTATS_KEYFRAME)
-                                 {
-                                         i_total += twopass->nns1.bytes + twopass->nns1.bytes * codec->config.keyframe_boost / 100;
-                                         total += twopass->nns1.bytes * codec->config.keyframe_boost / 100;
-                                         ++i_frames;
-                                 }
-                                 total += twopass->nns1.bytes;
-                                 ++frames;
-                         }
-                         // compensate for avi frame overhead
-                         desired -= frames * 24;
-                         switch (codec->config.credits_mode)
-                         {
-                         case CREDITS_MODE_RATE :
-                                 // credits curve = (total / desired_size) * (100 / credits_rate)
-                                 twopass->credits_start_curve = twopass->credits_end_curve =
-                                         ((float)total / desired) * ((float)100 / codec->config.credits_rate);
-                                 start_curved = (__int64)(start / twopass->credits_start_curve);
-                                 end_curved = (__int64)(end / twopass->credits_end_curve);
-                                 // movie curve = (total - credits) / (desired_size - curved credits)
-                                 twopass->movie_curve = (float)
-                                         (total - start - end) /
-                                         (desired - start_curved - end_curved);
-                                 break;
-                         case CREDITS_MODE_QUANT :
-                                 // movie curve = (total - credits) / (desired_size - credits)
-                                 twopass->movie_curve = (float)
-                                         (total - start - end) / (desired - start - end);
-                                 // aid the average asymmetric frame calculation below
-                                 start_curved = start;
-                                 end_curved = end;
-                                 break;
-                         case CREDITS_MODE_SIZE :
-                                 // start curve = (start / start desired size)
-                                 twopass->credits_start_curve = (float)
-                                         (start / 1024) / codec->config.credits_start_size;
-                                 // end curve = (end / end desired size)
-                                 twopass->credits_end_curve = (float)
-                                         (end / 1024) / codec->config.credits_end_size;
-                                 start_curved = (__int64)(start / twopass->credits_start_curve);
-                                 end_curved = (__int64)(end / twopass->credits_end_curve);
-                                 // movie curve = (total - credits) / (desired_size - curved credits)
-                                 twopass->movie_curve = (float)
-                                         (total - start - end) /
-                                         (desired - start_curved - end_curved);
-                                 break;
-                         }
-                         // average frame size = (desired - curved credits - curved keyframes) /
-                         //      (frames - credits frames - keyframes)
-                         twopass->average_frame = (double)
-                                 (desired - start_curved - end_curved - (i_total / twopass->movie_curve)) /
-                                 (frames - credits_frames - i_frames);
-                         SetFilePointer(twopass->stats1, sizeof(DWORD), 0, FILE_BEGIN);
-                         // perform prepass to compensate for over/undersizing
-                         frames = 0;
-                         if (codec->config.use_alt_curve)
-                         {
-                                 twopass->alt_curve_low = twopass->average_frame - twopass->average_frame * (double)codec->config.alt_curve_low_dist / 100.0;
-                                 twopass->alt_curve_low_diff = twopass->average_frame - twopass->alt_curve_low;
-                                 twopass->alt_curve_high = twopass->average_frame + twopass->average_frame * (double)codec->config.alt_curve_high_dist / 100.0;
-                                 twopass->alt_curve_high_diff = twopass->alt_curve_high - twopass->average_frame;
-                                 if (codec->config.alt_curve_use_auto)
-                                 {
-                                         if (twopass->movie_curve > 1.0f)
-                                         {
-                                                 codec->config.alt_curve_min_rel_qual = (int)(100.0 - (100.0 - 100.0 / twopass->movie_curve) * (double)codec->config.alt_curve_auto_str / 100.0);
-                                                 if (codec->config.alt_curve_min_rel_qual < 20)
-                                                         codec->config.alt_curve_min_rel_qual = 20;
-                                         }
-                                         else
-                                                 codec->config.alt_curve_min_rel_qual = 100;
-                                 }
-                                 twopass->alt_curve_mid_qual = (1.0 + (double)codec->config.alt_curve_min_rel_qual / 100.0) / 2.0;
-                                 twopass->alt_curve_qual_dev = 1.0 - twopass->alt_curve_mid_qual;
-                                 if (codec->config.alt_curve_low_dist > 100)
-                                 {
-                                         switch(codec->config.alt_curve_type)
-                                         {
-                                         case 2: // Sine Curve (high aggressiveness)
-                                                 twopass->alt_curve_qual_dev *= 2.0 / (1.0 +
-                                                         sin(DEG2RAD * (twopass->average_frame * 90.0 / twopass->alt_curve_low_diff)));
-                                                 twopass->alt_curve_mid_qual = 1.0 - twopass->alt_curve_qual_dev *
-                                                         sin(DEG2RAD * (twopass->average_frame * 90.0 / twopass->alt_curve_low_diff));
-                                                 break;
-                                         case 1: // Linear (medium aggressiveness)
-                                                 twopass->alt_curve_qual_dev *= 2.0 / (1.0 +
-                                                         twopass->average_frame / twopass->alt_curve_low_diff);
-                                                 twopass->alt_curve_mid_qual = 1.0 - twopass->alt_curve_qual_dev *
-                                                         twopass->average_frame / twopass->alt_curve_low_diff;
-                                                 break;
-                                         case 0: // Cosine Curve (low aggressiveness)
-                                                 twopass->alt_curve_qual_dev *= 2.0 / (1.0 +
-                                                         (1.0 - cos(DEG2RAD * (twopass->average_frame * 90.0 / twopass->alt_curve_low_diff))));
-                                                 twopass->alt_curve_mid_qual = 1.0 - twopass->alt_curve_qual_dev *
-                                                         (1.0 - cos(DEG2RAD * (twopass->average_frame * 90.0 / twopass->alt_curve_low_diff)));
-                                         }
-                                 }
-                         }
-                         while (1)
-                         {
-                                 if (!ReadFile(twopass->stats1, &twopass->nns1, sizeof(NNSTATS), &read, NULL) || read != sizeof(NNSTATS))
-                                 {
-                                         DWORD err = GetLastError();
-                                         if (err == ERROR_HANDLE_EOF || err == ERROR_SUCCESS)
-                                         {
-                                                 break;
-                                         }
-                                         else
-                                         {
-                                                 CloseHandle(twopass->stats1);
-                                                 twopass->stats1 = INVALID_HANDLE_VALUE;
-                                                 DEBUGERR("2pass init error - incomplete stats2 record?");
-                                                 return ICERR_ERROR;
-                                         }
-                                 }
-                                 if (!codec_is_in_credits(&codec->config, frames) &&
-                                         !(twopass->nns1.quant & NNSTATS_KEYFRAME))
-                                 {
-                                         double dbytes = twopass->nns1.bytes / twopass->movie_curve;
-                                         total1 += dbytes;
-                                         if (codec->config.use_alt_curve)
-                                         {
-                                                 if (dbytes > twopass->average_frame)
-                                                 {
-                                                         if (dbytes >= twopass->alt_curve_high)
-                                                                 total2 += dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev);
-                                                         else
-                                                         {
-                                                                 switch(codec->config.alt_curve_type)
-                                                                 {
-                                                                 case 2:
-                                                                 total2 += dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev *
-                                                                         sin(DEG2RAD * ((dbytes - twopass->average_frame) * 90.0 / twopass->alt_curve_high_diff)));
-                                                                         break;
-                                                                 case 1:
-                                                                 total2 += dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev *
-                                                                         (dbytes - twopass->average_frame) / twopass->alt_curve_high_diff);
-                                                                         break;
-                                                                 case 0:
-                                                                 total2 += dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev *
-                                                                         (1.0 - cos(DEG2RAD * ((dbytes - twopass->average_frame) * 90.0 / twopass->alt_curve_high_diff))));
-                                                                 }
-                                                         }
-                                                 }
-                                                 else
-                                                 {
-                                                         if (dbytes <= twopass->alt_curve_low)
-                                                                 total2 += dbytes;
-                                                         else
-                                                         {
-                                                                 switch(codec->config.alt_curve_type)
-                                                                 {
-                                                                 case 2:
-                                                                 total2 += dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev *
-                                                                         sin(DEG2RAD * ((dbytes - twopass->average_frame) * 90.0 / twopass->alt_curve_low_diff)));
-                                                                         break;
-                                                                 case 1:
-                                                                 total2 += dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev *
-                                                                         (dbytes - twopass->average_frame) / twopass->alt_curve_low_diff);
-                                                                         break;
-                                                                 case 0:
-                                                                 total2 += dbytes * (twopass->alt_curve_mid_qual + twopass->alt_curve_qual_dev *
-                                                                         (1.0 - cos(DEG2RAD * ((dbytes - twopass->average_frame) * 90.0 / twopass->alt_curve_low_diff))));
-                                                                 }
-                                                         }
-                                                 }
-                                         }
-                                         else
-                                         {
-                                                 if (dbytes > twopass->average_frame)
-                                                 {
-                                                         total2 += ((double)dbytes + (twopass->average_frame - dbytes) *
-                                                                 codec->config.curve_compression_high / 100.0);
-                                                 }
-                                                 else
-                                                 {
-                                                         total2 += ((double)dbytes + (twopass->average_frame - dbytes) *
-                                                                 codec->config.curve_compression_low / 100.0);
-                                                 }
-                                         }
-                                 }
-                                 ++frames;
-                         }
-                         twopass->curve_comp_scale = total1 / total2;
-                         if (!codec->config.use_alt_curve)
-                         {
-                                 int asymmetric_average_frame;
-                                 char s[100];
-                                 asymmetric_average_frame = (int)(twopass->average_frame * twopass->curve_comp_scale);
-                                 wsprintf(s, "middle frame size for asymmetric curve compression: %i", asymmetric_average_frame);
-                                 DEBUG2P(s);
-                         }
-                         SetFilePointer(twopass->stats1, sizeof(DWORD), 0, FILE_BEGIN);
-                 }
-                 if (codec->config.use_alt_curve)
-                 {
-                         if (codec->config.alt_curve_use_auto_bonus_bias)
-                                 codec->config.alt_curve_bonus_bias = codec->config.alt_curve_min_rel_qual;
-                         twopass->curve_bias_bonus = (total1 - total2) * (double)codec->config.alt_curve_bonus_bias / 100.0 / (double)(frames - credits_frames - i_frames);
-                         twopass->curve_comp_scale = ((total1 - total2) * (1.0 - (double)codec->config.alt_curve_bonus_bias / 100.0) + total2) / total2;
-                 }
-                 twopass->overflow = 0;
-                 break;
-         }
-         return ICERR_OK;
- }
+                 if (config->credits_greyscale)
- int codec_get_quant(CODEC* codec, XVID_ENC_FRAME* frame)
- {
-         switch (codec->config.mode)
-         {
-         case DLG_MODE_VBR_QUAL :
-                 if (codec_is_in_credits(&codec->config, codec->framenum))
-                 {
-                         switch (codec->config.credits_mode)
                          {
-                         case CREDITS_MODE_RATE :
-                                 frame->quant = codec_get_vbr_quant(&codec->config, codec->config.quality * codec->config.credits_rate / 100);
-                                 break;
-                         case CREDITS_MODE_QUANT :
+                         if ((frame->general && XVID_GREYSCALE))  // use only if not already in greyscale
-                                 frame->quant = codec->config.credits_quant_p;
-                                 break;
-                         default :
+                                 frame->general |= XVID_GREYSCALE;
-                                 DEBUGERR("Can't use credits size mode in quality mode");
-                                 return ICERR_ERROR;
-                         }
-                 }
-                 else
-                 {
-                         frame->quant = codec_get_vbr_quant(&codec->config, codec->config.quality);
-                 }
-                 return ICERR_OK;
-         case DLG_MODE_VBR_QUANT :
+                 } else {
-                 if (codec_is_in_credits(&codec->config, codec->framenum))
-                 {
-                         switch (codec->config.credits_mode)
-                         {
-                         case CREDITS_MODE_RATE :
-                                 frame->quant =
-                                         codec->config.max_pquant -
-                                         ((codec->config.max_pquant - codec->config.quant) * codec->config.credits_rate / 100);
-                                 break;
-                         case CREDITS_MODE_QUANT :
+                         if (!(frame->general && XVID_GREYSCALE))  // if movie is in greyscale, switch back
-                                 frame->quant = codec->config.credits_quant_p;
-                                 break;
-                         default :
+                                 frame->general |= XVID_GREYSCALE;
-                                 DEBUGERR("Can't use credits size mode in quantizer mode");
-                                 return ICERR_ERROR;
-                         }
-                 }
-                 else
-                 {
-                         frame->quant = codec->config.quant;
-                 }
-                 return ICERR_OK;
-         case DLG_MODE_2PASS_1 :
-                 if (codec->config.credits_mode == CREDITS_MODE_QUANT)
-                 {
-                         if (codec_is_in_credits(&codec->config, codec->framenum))
-                         {
-                                 frame->quant = codec->config.credits_quant_p;
                          }
-                         else
-                         {
-                                 frame->quant = 2;
-                         }
-                 }
-                 else
-                 {
-                         frame->quant = 2;
-                 }
-                 return ICERR_OK;
-         default:
+         } else {
-                 DEBUGERR("get quant: invalid mode");
-                 return ICERR_ERROR;
-         }
- }
+                 if (config->greyscale)
- int codec_2pass_get_quant(CODEC* codec, XVID_ENC_FRAME* frame)
  {
-         static double quant_error[32];
-         static double curve_comp_error;
-         static int last_quant;
-         TWOPASS * twopass = &codec->twopass;
+                         if ((frame->general && XVID_GREYSCALE))  // use only if not already in greyscale
-         DWORD read;
+                                 frame->general |= XVID_GREYSCALE;
-         int bytes1, bytes2;
-         int overflow;
-         int credits_pos;
-         if (codec->framenum == 0)
+                 } else {
-         {
-                 int i;
-                 for (i=0 ; i<32 ; ++i)
+                         if (!(frame->general && XVID_GREYSCALE))  // if credits is in greyscale, switch back
-                 {
-                         quant_error[i] = 0.0;
-                 }
-                 curve_comp_error = 0.0;
+                                 frame->general |= XVID_GREYSCALE;
-                 last_quant = 0;
-         }
-         if (ReadFile(twopass->stats1, &twopass->nns1, sizeof(NNSTATS), &read, 0) == 0 || read != sizeof(NNSTATS))
-         {
-                 DEBUGERR("2ndpass quant: couldn't read from stats1");
-                 return ICERR_ERROR;
-         }
-         if (codec->config.mode == DLG_MODE_2PASS_2_EXT)
-         {
-                 if (ReadFile(twopass->stats2, &twopass->nns2, sizeof(NNSTATS), &read, 0) == 0 || read != sizeof(NNSTATS))
-                 {
-                         DEBUGERR("2ndpass quant: couldn't read from stats2");
-                         return ICERR_ERROR;
                  }
-         }
-         bytes1 = twopass->nns1.bytes;
-         overflow = twopass->overflow / 8;
-         // override codec i-frame choice (reenable in credits)
-         frame->intra = (twopass->nns1.quant & NNSTATS_KEYFRAME);
-         if (frame->intra)
-         {
-                 overflow = 0;
-         }
-         credits_pos = codec_is_in_credits(&codec->config, codec->framenum);
-         if (credits_pos)
-         {
-                 if (codec->config.mode == DLG_MODE_2PASS_2_INT)
-                 {
-                         switch (codec->config.credits_mode)
-                         {
-                         case CREDITS_MODE_RATE :
-                         case CREDITS_MODE_SIZE :
-                                 if (credits_pos == CREDITS_START)
-                                 {
-                                         bytes2 = (int)(bytes1 / twopass->credits_start_curve);
-                                 }
-                                 else // CREDITS_END
-                                 {
-                                         bytes2 = (int)(bytes1 / twopass->credits_end_curve);
-                                 }
-                                 frame->intra = -1;
-                                 break;
-                         case CREDITS_MODE_QUANT :
-                                 if (codec->config.credits_quant_i != codec->config.credits_quant_p)
-                                 {
-                                         frame->quant = frame->intra ?
-                                                 codec->config.credits_quant_i :
-                                                 codec->config.credits_quant_p;
-                                 }
-                                 else
-                                 {
-                                         frame->quant = codec->config.credits_quant_p;
-                                         frame->intra = -1;
-                                 }
-                                 twopass->bytes1 = bytes1;
-                                 twopass->bytes2 = bytes1;
-                                 twopass->desired_bytes2 = bytes1;
-                                 return ICERR_OK;
-                         }
-                 }
-                 else    // DLG_MODE_2PASS_2_EXT
-                 {
-                         bytes2 = twopass->nns2.bytes;
-                 }
-         }
-         else    // Foxer: apply curve compression outside credits
-         {
-                 double dbytes, curve_temp;
-                 bytes2 = (codec->config.mode == DLG_MODE_2PASS_2_INT) ? bytes1 : twopass->nns2.bytes;
-                 if (frame->intra)
-                 {
-                         dbytes = ((int)(bytes2 + bytes2 * codec->config.keyframe_boost / 100)) /
-                                 twopass->movie_curve;
-                 }
-                 else
-                 {
-                         dbytes = bytes2 / twopass->movie_curve;
-                 }
-                 // spread the compression error across payback_delay frames
-                 if (codec->config.bitrate_payback_method == 0)
-                 {
-                         bytes2 = (int)(curve_comp_error / codec->config.bitrate_payback_delay);
-                 }
-                 else
-                 {
-                         bytes2 = (int)(curve_comp_error * dbytes /
-                                 twopass->average_frame / codec->config.bitrate_payback_delay);
-                         if (labs(bytes2) > fabs(curve_comp_error))
-                         {
-                                 bytes2 = (int)curve_comp_error;
-                         }
-                 }
-                 curve_comp_error -= bytes2;
-                 if (codec->config.use_alt_curve)
-                 {
-                         if (!frame->intra)
-                         {
-                                 if (dbytes > twopass->average_frame)
-                                 {
-                                         if (dbytes >= twopass->alt_curve_high)
-                                                 curve_temp = dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev);
-                                         else
-                                         {
-                                                 switch(codec->config.alt_curve_type)
-                                                 {
-                                                 case 2:
-                                                 curve_temp = dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev *
-                                                         sin(DEG2RAD * ((dbytes - twopass->average_frame) * 90.0 / twopass->alt_curve_high_diff)));
-                                                         break;
-                                                 case 1:
-                                                 curve_temp = dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev *
-                                                         (dbytes - twopass->average_frame) / twopass->alt_curve_high_diff);
-                                                         break;
-                                                 case 0:
-                                                 curve_temp = dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev *
-                                                         (1.0 - cos(DEG2RAD * ((dbytes - twopass->average_frame) * 90.0 / twopass->alt_curve_high_diff))));
-                                                 }
-                                         }
-                                 }
-                                 else
-                                 {
-                                         if (dbytes <= twopass->alt_curve_low)
-                                                 curve_temp = dbytes;
-                                         else
-                                         {
-                                                 switch(codec->config.alt_curve_type)
-                                                 {
-                                                 case 2:
-                                                 curve_temp = dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev *
-                                                         sin(DEG2RAD * ((dbytes - twopass->average_frame) * 90.0 / twopass->alt_curve_low_diff)));
-                                                         break;
-                                                 case 1:
-                                                 curve_temp = dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev *
-                                                         (dbytes - twopass->average_frame) / twopass->alt_curve_low_diff);
-                                                         break;
-                                                 case 0:
-                                                 curve_temp = dbytes * (twopass->alt_curve_mid_qual + twopass->alt_curve_qual_dev *
-                                                         (1.0 - cos(DEG2RAD * ((dbytes - twopass->average_frame) * 90.0 / twopass->alt_curve_low_diff))));
-                                                 }
-                                         }
-                                 }
-                                 curve_temp = curve_temp * twopass->curve_comp_scale + twopass->curve_bias_bonus;
-                                 bytes2 += ((int)curve_temp);
-                                 curve_comp_error += curve_temp - ((int)curve_temp);
-                         }
-                         else
-                         {
-                                 curve_comp_error += dbytes - ((int)dbytes);
-                                 bytes2 += ((int)dbytes);
-                         }
-                 }
-                 else if ((codec->config.curve_compression_high + codec->config.curve_compression_low) &&
-                         !frame->intra)
-                 {
-                         if (dbytes > twopass->average_frame)
-                         {
-                                 curve_temp = twopass->curve_comp_scale *
-                                         ((double)dbytes + (twopass->average_frame - dbytes) *
-                                         codec->config.curve_compression_high / 100.0);
-                         }
-                         else
-                         {
-                                 curve_temp = twopass->curve_comp_scale *
-                                         ((double)dbytes + (twopass->average_frame - dbytes) *
-                                         codec->config.curve_compression_low / 100.0);
-                         }
-                         bytes2 += ((int)curve_temp);
-                         curve_comp_error += curve_temp - ((int)curve_temp);
-                 }
-                 else
-                 {
-                         curve_comp_error += dbytes - ((int)dbytes);
-                         bytes2 += ((int)dbytes);
-                 }
-                 // cap bytes2 to first pass size, lowers number of quant=1 frames
-                 if (bytes2 > bytes1)
-                 {
-                         curve_comp_error += bytes2 - bytes1;
-                         bytes2 = bytes1;
-                 }
-                 else if (bytes2 < 1)
-                 {
-                         curve_comp_error += --bytes2;
-                         bytes2 = 1;
-                 }
-         }
-         twopass->desired_bytes2 = bytes2;
-         // Foxer: scale overflow in relation to average size, so smaller frames don't get
-         // too much/little bitrate
-         overflow = (int)((double)overflow * bytes2 / twopass->average_frame);
-         // Foxer: reign in overflow with huge frames
-         if (labs(overflow) > labs(twopass->overflow))
-         {
-                 overflow = twopass->overflow;
-         }
-         // Foxer: make sure overflow doesn't run away
-         if (overflow > bytes2 * 6 / 10)
-         {
-                 bytes2 += (overflow <= bytes2) ? bytes2 * 6 / 10 : overflow * 6 / 10;
-         }
-         else if (overflow < bytes2 * -6 / 10)
-         {
-                 bytes2 += bytes2 * -6 / 10;
-         }
-         else
-         {
-                 bytes2 += overflow;
-         }
-         if (bytes2 < 1)
-         {
-                 bytes2 = 1;
-         }
-         twopass->bytes1 = bytes1;
-         twopass->bytes2 = bytes2;
-         // very 'simple' quant<->filesize relationship
-         frame->quant = ((twopass->nns1.quant & ~NNSTATS_KEYFRAME) * bytes1) / bytes2;
-         if (frame->quant < 1)
-         {
-                 frame->quant = 1;
-         }
-         else if (frame->quant > 31)
-         {
-                 frame->quant = 31;
-         }
-         else if (!frame->intra)
-         {
-                 // Foxer: aid desired quantizer precision by accumulating decision error
-                 quant_error[frame->quant] += ((double)((twopass->nns1.quant & ~NNSTATS_KEYFRAME) *
-                         bytes1) / bytes2) - frame->quant;
-                 if (quant_error[frame->quant] >= 1.0)
-                 {
-                         quant_error[frame->quant] -= 1.0;
-                         ++frame->quant;
-                 }
-         }
-         // we're done with credits
-         if (codec_is_in_credits(&codec->config, codec->framenum))
-         {
-                 return ICERR_OK;
-         }
-         if (frame->intra)
-         {
-                 if (frame->quant < codec->config.min_iquant)
-                 {
-                         frame->quant = codec->config.min_iquant;
-                         DEBUG2P("I-frame quantizer raised");
-                 }
-                 if (frame->quant > codec->config.max_iquant)
-                 {
-                         frame->quant = codec->config.max_iquant;
-                         DEBUG2P("I-frame quantizer lowered");
-                 }
-         }
-         else
-         {
-                 if (frame->quant > codec->config.max_pquant)
-                 {
-                         frame->quant = codec->config.max_pquant;
-                 }
-                 if (frame->quant < codec->config.min_pquant)
-                 {
-                         frame->quant = codec->config.min_pquant;
-                 }
-                 // subsequent frame quants can only be +- 2
-                 if (last_quant)
-                 {
-                         if (frame->quant > last_quant + 2)
-                         {
-                                 frame->quant = last_quant + 2;
-                                 DEBUG2P("P-frame quantizer prevented from rising too steeply");
-                         }
-                         if (frame->quant < last_quant - 2)
-                         {
-                                 frame->quant = last_quant - 2;
-                                 DEBUG2P("P-frame quantizer prevented from falling too steeply");
-                         }
-                 }
-         }
-         last_quant = frame->quant;
-         if (codec->config.quant_type == QUANT_MODE_MOD)
-         {
-                 frame->general |= (frame->quant < 4) ? XVID_MPEGQUANT : XVID_H263QUANT;
-                 frame->general &= (frame->quant < 4) ? ~XVID_H263QUANT : ~XVID_MPEGQUANT;
-         }
-         return ICERR_OK;
- }
- int codec_2pass_update(CODEC* codec, XVID_ENC_FRAME* frame, XVID_ENC_STATS* stats)
- {
-         static __int64 total_size;
-         NNSTATS nns1;
-         DWORD wrote;
-         char* quant_type;
-         if (codec->framenum == 0)
-         {
-                 total_size = 0;
-         }
-         quant_type = (frame->general & XVID_H263QUANT) ? "H.263" :
-                 ((frame->general & XVID_MPEGQUANT) && (frame->general & XVID_CUSTOM_QMATRIX)) ?
-                 "Cust" : "MPEG";
-         switch (codec->config.mode)
-         {
-         case DLG_MODE_2PASS_1 :
-                 nns1.bytes = frame->length;     // total bytes
-                 nns1.dd_v = stats->hlength;     // header bytes
-                 nns1.dd_u = nns1.dd_y = 0;
-                 nns1.dk_v = nns1.dk_u = nns1.dk_y = 0;
-                 nns1.md_u = nns1.md_y = 0;
-                 nns1.mk_u = nns1.mk_y = 0;
-                 nns1.quant = stats->quant;
-                 if (frame->intra)
-                 {
-                         nns1.quant |= NNSTATS_KEYFRAME;
-                 }
-                 nns1.kblk = stats->kblks;
-                 nns1.mblk = stats->mblks;
-                 nns1.ublk = stats->ublks;
-                 nns1.lum_noise[0] = nns1.lum_noise[1] = 1;
-                 total_size += frame->length;
-                 DEBUG1ST(frame->length, (int)total_size/1024, frame->intra, frame->quant, quant_type, stats->kblks, stats->mblks)
-                 if (WriteFile(codec->twopass.stats1, &nns1, sizeof(NNSTATS), &wrote, 0) == 0 || wrote != sizeof(NNSTATS))
-                 {
-                         DEBUGERR("stats1: WriteFile error");
-                         return ICERR_ERROR;
-                 }
-                 break;
-         case DLG_MODE_2PASS_2_INT :
-         case DLG_MODE_2PASS_2_EXT :
-                 codec->twopass.overflow += codec->twopass.desired_bytes2 - frame->length;
-                 DEBUG2ND(frame->quant, quant_type, frame->intra, codec->twopass.bytes1, codec->twopass.desired_bytes2, frame->length, codec->twopass.overflow, codec_is_in_credits(&codec->config, codec->framenum))
-                 break;
-         default:
-                 break;
-         }
-         return ICERR_OK;
- }
- int codec_is_in_credits(CONFIG* config, int framenum)
- {
-         if (config->credits_start)
-         {
-                 if (framenum >= config->credits_start_begin &&
-                         framenum <= config->credits_start_end)
-                 {
-                         return CREDITS_START;
-                 }
-         }
-         if (config->credits_end)
-         {
-                 if (framenum >= config->credits_end_begin &&
-                         framenum <= config->credits_end_end)
-                 {
-                         return CREDITS_END;
-                 }
          }
          return 0;
- }
- int codec_get_vbr_quant(CONFIG* config, int quality)
- {
-         static float fquant_running = 0;
-         static int my_quality = -1;
-         int     quant;
-         // if quality changes, recalculate fquant (credits)
-         if (quality != my_quality)
-         {
-                 config->fquant = 0;
          }
-         my_quality = quality;
+ // end of koepi's addition
-         // desired quantiser = (maxQ-minQ)/100 * (100-qual) + minQ
-         if (!config->fquant)
-         {
-                 config->fquant =
-                         ((float) (config->max_pquant - config->min_pquant) / 100) *
-                         (100 - quality) +
-                         (float) config->min_pquant;
-                 fquant_running = config->fquant;
-         }
-         if (fquant_running < config->min_pquant)
-         {
-                 fquant_running = (float) config->min_pquant;
-         }
-         else if(fquant_running > config->max_pquant)
-         {
-                 fquant_running = (float) config->max_pquant;
-         }
-         quant = (int) fquant_running;
-         // add error between fquant and quant to fquant_running
-         fquant_running += config->fquant - quant;
-         return quant;
- }

 Legend:



Removed from v.61
 


changed lines


 
Added in v.901
 Legend:



Removed from v.61
 


changed lines


 
Added in v.901
-Removed from v.61
+Added in v.901

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