[svn] / trunk / vfw / src / 2pass.c Repository:
ViewVC logotype

Diff of /trunk/vfw/src/2pass.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 105, Sat Apr 6 06:21:29 2002 UTC revision 527, Mon Sep 23 06:10:43 2002 UTC
# Line 23  Line 23 
23   *   *
24   *      History:   *      History:
25   *   *
26     *      17.04.2002      changed 1st pass quant to always be 2 (2pass_update())
27     *      07.04.2002      added max bitrate constraint, overflow controls (foxer)
28   *      31.03.2002      inital version;   *      31.03.2002      inital version;
29   *   *
30   *************************************************************************/   *************************************************************************/
# Line 45  Line 47 
47    
48          double total1 = 0.0;          double total1 = 0.0;
49          double total2 = 0.0;          double total2 = 0.0;
50            double dbytes, dbytes2;
51    
52          if (codec->config.hinted_me)          if (codec->config.hinted_me)
53          {          {
# Line 159  Line 162 
162                                  {                                  {
163                                          if (twopass->nns1.quant & NNSTATS_KEYFRAME)                                          if (twopass->nns1.quant & NNSTATS_KEYFRAME)
164                                          {                                          {
165                                                  i_boost_total = twopass->nns2.bytes * codec->config.keyframe_boost / 100;                                                  i_boost_total += twopass->nns2.bytes * codec->config.keyframe_boost / 100;
166                                                  i_total += twopass->nns2.bytes;                                                  i_total += twopass->nns2.bytes;
167                                                    twopass->keyframe_locations[i_frames] = frames;
168                                                  ++i_frames;                                                  ++i_frames;
169                                          }                                          }
170    
# Line 172  Line 176 
176    
177                                  ++frames;                                  ++frames;
178                          }                          }
179                            twopass->keyframe_locations[i_frames] = frames;
180    
181                          twopass->movie_curve = ((double)(total_ext + i_boost_total) / total_ext);                          twopass->movie_curve = ((double)(total_ext + i_boost_total) / total_ext);
182                          twopass->average_frame = ((double)(total_ext - i_total) / (frames - credits_frames - i_frames) / twopass->movie_curve);                          twopass->average_frame = ((double)(total_ext - i_total) / (frames - credits_frames - i_frames) / twopass->movie_curve);
# Line 248  Line 253 
253                                          }                                          }
254                                  }                                  }
255    
256                                    if (frames == 0)
257                                    {
258                                            twopass->minpsize = (twopass->nns1.kblk + 88) / 8;
259                                            twopass->minisize = ((twopass->nns1.kblk * 22) + 240) / 8;
260                                    }
261    
262                                  if (!codec_is_in_credits(&codec->config, frames) &&                                  if (!codec_is_in_credits(&codec->config, frames) &&
263                                          !(twopass->nns1.quant & NNSTATS_KEYFRAME))                                          !(twopass->nns1.quant & NNSTATS_KEYFRAME))
264                                  {                                  {
265                                          double dbytes = twopass->nns2.bytes / twopass->movie_curve;                                          dbytes = twopass->nns2.bytes / twopass->movie_curve;
266                                          total1 += dbytes;                                          total1 += dbytes;
267    
268                                          if (codec->config.use_alt_curve)                                          if (codec->config.use_alt_curve)
# Line 259  Line 270 
270                                                  if (dbytes > twopass->average_frame)                                                  if (dbytes > twopass->average_frame)
271                                                  {                                                  {
272                                                          if (dbytes >= twopass->alt_curve_high)                                                          if (dbytes >= twopass->alt_curve_high)
273                                                                  total2 += dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev);                                                                  dbytes2 = dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev);
274                                                          else                                                          else
275                                                          {                                                          {
276                                                                  switch(codec->config.alt_curve_type)                                                                  switch(codec->config.alt_curve_type)
277                                                                  {                                                                  {
278                                                                  case 2:                                                                  case 2:
279                                                                  total2 += dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev *                                                                  dbytes2 = dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev *
280                                                                          sin(DEG2RAD * ((dbytes - twopass->average_frame) * 90.0 / twopass->alt_curve_high_diff)));                                                                          sin(DEG2RAD * ((dbytes - twopass->average_frame) * 90.0 / twopass->alt_curve_high_diff)));
281                                                                          break;                                                                          break;
282                                                                  case 1:                                                                  case 1:
283                                                                  total2 += dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev *                                                                  dbytes2 = dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev *
284                                                                          (dbytes - twopass->average_frame) / twopass->alt_curve_high_diff);                                                                          (dbytes - twopass->average_frame) / twopass->alt_curve_high_diff);
285                                                                          break;                                                                          break;
286                                                                  case 0:                                                                  case 0:
287                                                                  total2 += dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev *                                                                  dbytes2 = dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev *
288                                                                          (1.0 - cos(DEG2RAD * ((dbytes - twopass->average_frame) * 90.0 / twopass->alt_curve_high_diff))));                                                                          (1.0 - cos(DEG2RAD * ((dbytes - twopass->average_frame) * 90.0 / twopass->alt_curve_high_diff))));
289                                                                  }                                                                  }
290                                                          }                                                          }
# Line 281  Line 292 
292                                                  else                                                  else
293                                                  {                                                  {
294                                                          if (dbytes <= twopass->alt_curve_low)                                                          if (dbytes <= twopass->alt_curve_low)
295                                                                  total2 += dbytes;                                                                  dbytes2 = dbytes;
296                                                          else                                                          else
297                                                          {                                                          {
298                                                                  switch(codec->config.alt_curve_type)                                                                  switch(codec->config.alt_curve_type)
299                                                                  {                                                                  {
300                                                                  case 2:                                                                  case 2:
301                                                                  total2 += dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev *                                                                  dbytes2 = dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev *
302                                                                          sin(DEG2RAD * ((dbytes - twopass->average_frame) * 90.0 / twopass->alt_curve_low_diff)));                                                                          sin(DEG2RAD * ((dbytes - twopass->average_frame) * 90.0 / twopass->alt_curve_low_diff)));
303                                                                          break;                                                                          break;
304                                                                  case 1:                                                                  case 1:
305                                                                  total2 += dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev *                                                                  dbytes2 = dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev *
306                                                                          (dbytes - twopass->average_frame) / twopass->alt_curve_low_diff);                                                                          (dbytes - twopass->average_frame) / twopass->alt_curve_low_diff);
307                                                                          break;                                                                          break;
308                                                                  case 0:                                                                  case 0:
309                                                                  total2 += dbytes * (twopass->alt_curve_mid_qual + twopass->alt_curve_qual_dev *                                                                  dbytes2 = dbytes * (twopass->alt_curve_mid_qual + twopass->alt_curve_qual_dev *
310                                                                          (1.0 - cos(DEG2RAD * ((dbytes - twopass->average_frame) * 90.0 / twopass->alt_curve_low_diff))));                                                                          (1.0 - cos(DEG2RAD * ((dbytes - twopass->average_frame) * 90.0 / twopass->alt_curve_low_diff))));
311                                                                  }                                                                  }
312                                                          }                                                          }
# Line 305  Line 316 
316                                          {                                          {
317                                                  if (dbytes > twopass->average_frame)                                                  if (dbytes > twopass->average_frame)
318                                                  {                                                  {
319                                                          total2 += ((double)dbytes + (twopass->average_frame - dbytes) *                                                          dbytes2 = ((double)dbytes + (twopass->average_frame - dbytes) *
320                                                                  codec->config.curve_compression_high / 100.0);                                                                  codec->config.curve_compression_high / 100.0);
321                                                  }                                                  }
322                                                  else                                                  else
323                                                  {                                                  {
324                                                          total2 += ((double)dbytes + (twopass->average_frame - dbytes) *                                                          dbytes2 = ((double)dbytes + (twopass->average_frame - dbytes) *
325                                                                  codec->config.curve_compression_low / 100.0);                                                                  codec->config.curve_compression_low / 100.0);
326                                                  }                                                  }
327                                          }                                          }
328    
329                                            if (dbytes2 < twopass->minpsize)
330                                                    dbytes2 = twopass->minpsize;
331    
332                                            total2 += dbytes2;
333                                  }                                  }
334    
335                                  ++frames;                                  ++frames;
# Line 369  Line 385 
385                                  {                                  {
386                                          i_total += twopass->nns1.bytes + twopass->nns1.bytes * codec->config.keyframe_boost / 100;                                          i_total += twopass->nns1.bytes + twopass->nns1.bytes * codec->config.keyframe_boost / 100;
387                                          total += twopass->nns1.bytes * codec->config.keyframe_boost / 100;                                          total += twopass->nns1.bytes * codec->config.keyframe_boost / 100;
388                                            twopass->keyframe_locations[i_frames] = frames;
389                                          ++i_frames;                                          ++i_frames;
390                                  }                                  }
391    
# Line 376  Line 393 
393    
394                                  ++frames;                                  ++frames;
395                          }                          }
396                            twopass->keyframe_locations[i_frames] = frames;
397    
398                          // compensate for avi frame overhead                          // compensate for avi frame overhead
399                          desired -= frames * 24;                          desired -= frames * 24;
# Line 505  Line 523 
523                                          }                                          }
524                                  }                                  }
525    
526                                    if (frames == 0)
527                                    {
528                                            twopass->minpsize = (twopass->nns1.kblk + 88) / 8;
529                                            twopass->minisize = ((twopass->nns1.kblk * 22) + 240) / 8;
530                                    }
531    
532                                  if (!codec_is_in_credits(&codec->config, frames) &&                                  if (!codec_is_in_credits(&codec->config, frames) &&
533                                          !(twopass->nns1.quant & NNSTATS_KEYFRAME))                                          !(twopass->nns1.quant & NNSTATS_KEYFRAME))
534                                  {                                  {
535                                          double dbytes = twopass->nns1.bytes / twopass->movie_curve;                                          dbytes = twopass->nns1.bytes / twopass->movie_curve;
536                                          total1 += dbytes;                                          total1 += dbytes;
537    
538                                          if (codec->config.use_alt_curve)                                          if (codec->config.use_alt_curve)
# Line 516  Line 540 
540                                                  if (dbytes > twopass->average_frame)                                                  if (dbytes > twopass->average_frame)
541                                                  {                                                  {
542                                                          if (dbytes >= twopass->alt_curve_high)                                                          if (dbytes >= twopass->alt_curve_high)
543                                                                  total2 += dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev);                                                                  dbytes2 = dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev);
544                                                          else                                                          else
545                                                          {                                                          {
546                                                                  switch(codec->config.alt_curve_type)                                                                  switch(codec->config.alt_curve_type)
547                                                                  {                                                                  {
548                                                                  case 2:                                                                  case 2:
549                                                                  total2 += dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev *                                                                  dbytes2 = dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev *
550                                                                          sin(DEG2RAD * ((dbytes - twopass->average_frame) * 90.0 / twopass->alt_curve_high_diff)));                                                                          sin(DEG2RAD * ((dbytes - twopass->average_frame) * 90.0 / twopass->alt_curve_high_diff)));
551                                                                          break;                                                                          break;
552                                                                  case 1:                                                                  case 1:
553                                                                  total2 += dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev *                                                                  dbytes2 = dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev *
554                                                                          (dbytes - twopass->average_frame) / twopass->alt_curve_high_diff);                                                                          (dbytes - twopass->average_frame) / twopass->alt_curve_high_diff);
555                                                                          break;                                                                          break;
556                                                                  case 0:                                                                  case 0:
557                                                                  total2 += dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev *                                                                  dbytes2 = dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev *
558                                                                          (1.0 - cos(DEG2RAD * ((dbytes - twopass->average_frame) * 90.0 / twopass->alt_curve_high_diff))));                                                                          (1.0 - cos(DEG2RAD * ((dbytes - twopass->average_frame) * 90.0 / twopass->alt_curve_high_diff))));
559                                                                  }                                                                  }
560                                                          }                                                          }
# Line 538  Line 562 
562                                                  else                                                  else
563                                                  {                                                  {
564                                                          if (dbytes <= twopass->alt_curve_low)                                                          if (dbytes <= twopass->alt_curve_low)
565                                                                  total2 += dbytes;                                                                  dbytes2 = dbytes;
566                                                          else                                                          else
567                                                          {                                                          {
568                                                                  switch(codec->config.alt_curve_type)                                                                  switch(codec->config.alt_curve_type)
569                                                                  {                                                                  {
570                                                                  case 2:                                                                  case 2:
571                                                                  total2 += dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev *                                                                  dbytes2 = dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev *
572                                                                          sin(DEG2RAD * ((dbytes - twopass->average_frame) * 90.0 / twopass->alt_curve_low_diff)));                                                                          sin(DEG2RAD * ((dbytes - twopass->average_frame) * 90.0 / twopass->alt_curve_low_diff)));
573                                                                          break;                                                                          break;
574                                                                  case 1:                                                                  case 1:
575                                                                  total2 += dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev *                                                                  dbytes2 = dbytes * (twopass->alt_curve_mid_qual - twopass->alt_curve_qual_dev *
576                                                                          (dbytes - twopass->average_frame) / twopass->alt_curve_low_diff);                                                                          (dbytes - twopass->average_frame) / twopass->alt_curve_low_diff);
577                                                                          break;                                                                          break;
578                                                                  case 0:                                                                  case 0:
579                                                                  total2 += dbytes * (twopass->alt_curve_mid_qual + twopass->alt_curve_qual_dev *                                                                  dbytes2 = dbytes * (twopass->alt_curve_mid_qual + twopass->alt_curve_qual_dev *
580                                                                          (1.0 - cos(DEG2RAD * ((dbytes - twopass->average_frame) * 90.0 / twopass->alt_curve_low_diff))));                                                                          (1.0 - cos(DEG2RAD * ((dbytes - twopass->average_frame) * 90.0 / twopass->alt_curve_low_diff))));
581                                                                  }                                                                  }
582                                                          }                                                          }
# Line 562  Line 586 
586                                          {                                          {
587                                                  if (dbytes > twopass->average_frame)                                                  if (dbytes > twopass->average_frame)
588                                                  {                                                  {
589                                                          total2 += ((double)dbytes + (twopass->average_frame - dbytes) *                                                          dbytes2 = ((double)dbytes + (twopass->average_frame - dbytes) *
590                                                                  codec->config.curve_compression_high / 100.0);                                                                  codec->config.curve_compression_high / 100.0);
591                                                  }                                                  }
592                                                  else                                                  else
593                                                  {                                                  {
594                                                          total2 += ((double)dbytes + (twopass->average_frame - dbytes) *                                                          dbytes2 = ((double)dbytes + (twopass->average_frame - dbytes) *
595                                                                  codec->config.curve_compression_low / 100.0);                                                                  codec->config.curve_compression_low / 100.0);
596                                                  }                                                  }
597                                          }                                          }
598    
599                                            if (dbytes2 < twopass->minpsize)
600                                                    dbytes2 = twopass->minpsize;
601    
602                                            total2 += dbytes2;
603                                  }                                  }
604    
605                                  ++frames;                                  ++frames;
# Line 680  Line 709 
709                  }                  }
710    
711                  twopass->overflow = 0;                  twopass->overflow = 0;
712                    twopass->KFoverflow = 0;
713                    twopass->KFoverflow_partial = 0;
714                    twopass->KF_idx = 1;
715    
716                  break;                  break;
717          }          }
# Line 700  Line 732 
732          int bytes1, bytes2;          int bytes1, bytes2;
733          int overflow;          int overflow;
734          int credits_pos;          int credits_pos;
735            int capped_to_max_framesize = 0;
736            int KFdistance, KF_min_size;
737    
738          if (codec->framenum == 0)          if (codec->framenum == 0)
739          {          {
# Line 783  Line 817 
817                  }                  }
818                  else    // DLG_MODE_2PASS_2_EXT                  else    // DLG_MODE_2PASS_2_EXT
819                  {                  {
820                            if (codec->config.credits_mode == CREDITS_MODE_QUANT)
821                            {
822                                    if (codec->config.credits_quant_i != codec->config.credits_quant_p)
823                                    {
824                                            frame->quant = frame->intra ?
825                                                    codec->config.credits_quant_i :
826                                                    codec->config.credits_quant_p;
827                                    }
828                                    else
829                                    {
830                                            frame->quant = codec->config.credits_quant_p;
831                                            frame->intra = -1;
832                                    }
833    
834                                    twopass->bytes1 = bytes1;
835                                    twopass->bytes2 = bytes1;
836                                    twopass->desired_bytes2 = bytes1;
837                                    return ICERR_OK;
838                            }
839                            else
840                          bytes2 = twopass->nns2.bytes;                          bytes2 = twopass->nns2.bytes;
841                  }                  }
842          }          }
# Line 904  Line 958 
958                          bytes2 += ((int)dbytes);                          bytes2 += ((int)dbytes);
959                  }                  }
960    
961                    if (frame->intra)
962                    {
963                            if (bytes2 < twopass->minisize)
964                            {
965                                    curve_comp_error -= twopass->minisize - bytes2;
966                                    bytes2 = twopass->minisize;
967                            }
968                    }
969                    else
970                    {
971                  // cap bytes2 to first pass size, lowers number of quant=1 frames                  // cap bytes2 to first pass size, lowers number of quant=1 frames
972                  if (bytes2 > bytes1)                  if (bytes2 > bytes1)
973                  {                  {
974                          curve_comp_error += bytes2 - bytes1;                          curve_comp_error += bytes2 - bytes1;
975                          bytes2 = bytes1;                          bytes2 = bytes1;
976                  }                  }
977                  else if (bytes2 < 1)                          else if (bytes2 < twopass->minpsize)
978                  {                                  bytes2 = twopass->minpsize;
                         curve_comp_error += --bytes2;  
                         bytes2 = 1;  
979                  }                  }
980          }          }
981    
982          twopass->desired_bytes2 = bytes2;          twopass->desired_bytes2 = bytes2;
983    
984            // if this keyframe is too close to the next,
985            // reduce it's byte allotment
986            if (frame->intra && !credits_pos)
987            {
988                    KFdistance = codec->twopass.keyframe_locations[codec->twopass.KF_idx] -
989                            codec->twopass.keyframe_locations[codec->twopass.KF_idx - 1];
990    
991                    if (KFdistance < codec->config.kftreshold)
992                    {
993                            KFdistance = KFdistance - codec->config.min_key_interval;
994    
995                            if (KFdistance >= 0)
996                            {
997                                    KF_min_size = bytes2 * (100 - codec->config.kfreduction) / 100;
998                                    if (KF_min_size < 1)
999                                            KF_min_size = 1;
1000    
1001                                    bytes2 = KF_min_size + (bytes2 - KF_min_size) * KFdistance /
1002                                            (codec->config.kftreshold - codec->config.min_key_interval);
1003    
1004                                    if (bytes2 < 1)
1005                                            bytes2 = 1;
1006                            }
1007                    }
1008            }
1009    
1010          // Foxer: scale overflow in relation to average size, so smaller frames don't get          // Foxer: scale overflow in relation to average size, so smaller frames don't get
1011          // too much/little bitrate          // too much/little bitrate
1012          overflow = (int)((double)overflow * bytes2 / twopass->average_frame);          overflow = (int)((double)overflow * bytes2 / twopass->average_frame *
1013                    (bytes1 - bytes2) / bytes1);
1014    
1015          // Foxer: reign in overflow with huge frames          // Foxer: reign in overflow with huge frames
1016          if (labs(overflow) > labs(twopass->overflow))          if (labs(overflow) > labs(twopass->overflow))
# Line 930  Line 1019 
1019          }          }
1020    
1021          // Foxer: make sure overflow doesn't run away          // Foxer: make sure overflow doesn't run away
1022          if (overflow > bytes2 * 6 / 10)          if (overflow > bytes2 * codec->config.twopass_max_overflow_improvement / 100)
1023          {          {
1024                  bytes2 += (overflow <= bytes2) ? bytes2 * 6 / 10 : overflow * 6 / 10;                  bytes2 += (overflow <= bytes2) ? bytes2 * codec->config.twopass_max_overflow_improvement / 100 :
1025                            overflow * codec->config.twopass_max_overflow_improvement / 100;
1026          }          }
1027          else if (overflow < bytes2 * -6 / 10)          else if (overflow < bytes2 * codec->config.twopass_max_overflow_degradation / -100)
1028          {          {
1029                  bytes2 += bytes2 * -6 / 10;                  bytes2 += bytes2 * codec->config.twopass_max_overflow_degradation / -100;
1030          }          }
1031          else          else
1032          {          {
1033                  bytes2 += overflow;                  bytes2 += overflow;
1034          }          }
1035    
1036            if (bytes2 > twopass->max_framesize)
1037            {
1038                    capped_to_max_framesize = 1;
1039                    bytes2 = twopass->max_framesize;
1040            }
1041    
1042          if (bytes2 < 1)          if (bytes2 < 1)
1043          {          {
1044                  bytes2 = 1;                  bytes2 = 1;
# Line 1006  Line 1102 
1102                  }                  }
1103    
1104                  // subsequent frame quants can only be +- 2                  // subsequent frame quants can only be +- 2
1105                  if (last_quant)                  if (last_quant && capped_to_max_framesize == 0)
1106                  {                  {
1107                          if (frame->quant > last_quant + 2)                          if (frame->quant > last_quant + 2)
1108                          {                          {
# Line 1021  Line 1117 
1117                  }                  }
1118          }          }
1119    
1120            if (capped_to_max_framesize == 0)
1121          last_quant = frame->quant;          last_quant = frame->quant;
1122    
1123          if (codec->config.quant_type == QUANT_MODE_MOD)          if (codec->config.quant_type == QUANT_MODE_MOD)
# Line 1039  Line 1136 
1136    
1137          NNSTATS nns1;          NNSTATS nns1;
1138          DWORD wrote;          DWORD wrote;
1139          int credits_pos;          int credits_pos, tempdiv;
1140          char* quant_type;          char* quant_type;
1141    
1142          if (codec->framenum == 0)          if (codec->framenum == 0)
# Line 1062  Line 1159 
1159                  nns1.md_u = nns1.md_y = 0;                  nns1.md_u = nns1.md_y = 0;
1160                  nns1.mk_u = nns1.mk_y = 0;                  nns1.mk_u = nns1.mk_y = 0;
1161    
1162                  nns1.quant = stats->quant;  //              nns1.quant = stats->quant;
1163                    nns1.quant = 2;                         // ugly fix for lumi masking in 1st pass returning new quant
1164                  if (frame->intra)                  if (frame->intra)
1165                  {                  {
1166                          nns1.quant |= NNSTATS_KEYFRAME;                          nns1.quant |= NNSTATS_KEYFRAME;
# Line 1085  Line 1183 
1183    
1184          case DLG_MODE_2PASS_2_INT :          case DLG_MODE_2PASS_2_INT :
1185          case DLG_MODE_2PASS_2_EXT :          case DLG_MODE_2PASS_2_EXT :
                 codec->twopass.overflow += codec->twopass.desired_bytes2 - frame->length;  
   
1186                  credits_pos = codec_is_in_credits(&codec->config, codec->framenum);                  credits_pos = codec_is_in_credits(&codec->config, codec->framenum);
1187                  if (!credits_pos)                  if (!credits_pos)
1188                    {
1189                          codec->twopass.quant_count[frame->quant]++;                          codec->twopass.quant_count[frame->quant]++;
1190                            if ((codec->twopass.nns1.quant & NNSTATS_KEYFRAME))
1191                            {
1192                                    // calculate how much to distribute per frame in
1193                                    // order to make up for this keyframe's overflow
1194    
1195                                    codec->twopass.overflow += codec->twopass.KFoverflow;
1196                                    codec->twopass.KFoverflow = codec->twopass.desired_bytes2 - frame->length;
1197    
1198                                    tempdiv = (codec->twopass.keyframe_locations[codec->twopass.KF_idx] -
1199                                            codec->twopass.keyframe_locations[codec->twopass.KF_idx - 1]);
1200    
1201                                    if (tempdiv > 1)
1202                                    {
1203                                            // non-consecutive keyframes
1204                                            codec->twopass.KFoverflow_partial = codec->twopass.KFoverflow / (tempdiv - 1);
1205                                    }
1206                                    else
1207                                    {
1208                                            // consecutive keyframes
1209                                            codec->twopass.overflow += codec->twopass.KFoverflow;
1210                                            codec->twopass.KFoverflow = 0;
1211                                            codec->twopass.KFoverflow_partial = 0;
1212                                    }
1213                                    codec->twopass.KF_idx++;
1214                            }
1215                            else
1216                            {
1217                                    // distribute part of the keyframe overflow
1218    
1219                                    codec->twopass.overflow += codec->twopass.desired_bytes2 - frame->length +
1220                                            codec->twopass.KFoverflow_partial;
1221                                    codec->twopass.KFoverflow -= codec->twopass.KFoverflow_partial;
1222                            }
1223                    }
1224                    else
1225                    {
1226                            codec->twopass.overflow += codec->twopass.desired_bytes2 - frame->length;
1227    
1228                            // ugly fix for credits..
1229                            codec->twopass.overflow += codec->twopass.KFoverflow;
1230                            codec->twopass.KFoverflow = 0;
1231                            codec->twopass.KFoverflow_partial = 0;
1232                            // end of ugly fix.
1233                    }
1234    
1235                  DEBUG2ND(frame->quant, quant_type, frame->intra, codec->twopass.bytes1, codec->twopass.desired_bytes2, frame->length, codec->twopass.overflow, credits_pos)                  DEBUG2ND(frame->quant, quant_type, frame->intra, codec->twopass.bytes1, codec->twopass.desired_bytes2, frame->length, codec->twopass.overflow, credits_pos)
1236                  break;                  break;
Legend:
Removed from v.105  
changed lines
  Added in v.527
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4