2pass.cpp.svn-base

ffshow源码

									break;
								case 1:
								dbytes2 = dbytes * (twopass.alt_curve_mid_qual - twopass.alt_curve_qual_dev *
									(dbytes - twopass.average_pframe) / twopass.alt_curve_low_diff);
									break;
								case 0:
								dbytes2 = dbytes * (twopass.alt_curve_mid_qual + twopass.alt_curve_qual_dev *
									(1.0 - cos(DEG2RAD * ((dbytes - twopass.average_pframe) * 90.0 / twopass.alt_curve_low_diff))));
								}
							}
						}
					}
					else
					{
						if (dbytes > twopass.average_pframe)
						{
							dbytes2 = ((double)dbytes + (twopass.average_pframe - dbytes) *
								config.curve_compression_high / 100.0);
						}
						else
						{
							dbytes2 = ((double)dbytes + (twopass.average_pframe - dbytes) *
								config.curve_compression_low / 100.0);
						}
					}

					if (twopass.nns1.dd_v & NNSTATS_BFRAME)
					{
						dbytes2 *= twopass.average_bframe / twopass.average_pframe;
						if (dbytes2 < twopass.minbsize)
							dbytes2 = twopass.minbsize;
					}
					else
					{
						if (dbytes2 < twopass.minpsize)
							dbytes2 = twopass.minpsize;
					}

					total2 += dbytes2;
				}

				++frames;
			}

			twopass.curve_comp_scale = total1 / total2;

			if (!config.use_alt_curve)
			{
				int asymmetric_average_frame;
				char_t s[100];

				asymmetric_average_frame = (int)(twopass.average_pframe * twopass.curve_comp_scale);
				wsprintf(s, _l("middle frame size for asymmetric curve compression: %i"), asymmetric_average_frame);
				DEBUG2P(s);
			}
		}
		else	// DLG_MODE_2PASS_2_INT
		{
			while (1)
			{
				if (twopass.nns_array_pos >= twopass.nns_array_length)
				{
					twopass.nns_array_pos = 0;
					break;
				}

				memcpy(&twopass.nns1, &twopass.nns1_array[twopass.nns_array_pos], sizeof(NNSTATS));
				twopass.nns_array_pos++;

				// skip unnecessary frames.
				if (twopass.nns1.dd_v & NNSTATS_SKIPFRAME ||
					twopass.nns1.dd_v & NNSTATS_PADFRAME ||
					twopass.nns1.dd_v & NNSTATS_DELAYFRAME)
					continue;

				if (codec_is_in_credits( frames) == CREDITS_START)
				{
					start += twopass.nns1.bytes;
					++credits_frames;
				}
				else if (codec_is_in_credits( frames) == CREDITS_END)
				{
					end += twopass.nns1.bytes;
					++credits_frames;
				}
				else if (twopass.nns1.quant & NNSTATS_KEYFRAME)
				{
					i_total += twopass.nns1.bytes + twopass.nns1.bytes * config.keyframe_boost / 100;
					twopass.keyframe_locations[i_frames] = frames;
					++i_frames;
				}
				else
				{
					if (twopass.nns1.dd_v & NNSTATS_BFRAME)
					{
						bframe_total += twopass.nns1.bytes;
						bframes++;
					}
					else
					{
						pframe_total += twopass.nns1.bytes;
						pframes++;
					}
				}

				if (twopass.nns1.quant & NNSTATS_KEYFRAME)
				{
					// this test needs to be corrected..
					if (!(twopass.nns1.kblk + twopass.nns1.mblk))
						recminisize = twopass.nns1.bytes;
				}
				else if (twopass.nns1.dd_v & NNSTATS_BFRAME)
				{
					if (!(twopass.nns1.kblk + twopass.nns1.mblk))
						recminbsize = twopass.nns1.bytes;
				}
				else
				{
					if (!(twopass.nns1.kblk + twopass.nns1.mblk))
						recminpsize = twopass.nns1.bytes;
				}

				++frames;
			}
			twopass.keyframe_locations[i_frames] = frames;

			// compensate for avi frame overhead
			desired -= frames * 24;

			switch (config.credits_mode)
			{
			case CREDITS_MODE_RATE :

				// credits curve = (total / desired_size) * (100 / credits_rate)
				twopass.credits_start_curve = twopass.credits_end_curve =
					((double)(bframe_total + pframe_total + i_total + start + end) / desired) *
					((double)100 / config.credits_percent);

				start_curved = (int64_t)(start / twopass.credits_start_curve);
				end_curved = (int64_t)(end / twopass.credits_end_curve);

				// movie curve = (total - credits) / (desired_size - curved credits)
				twopass.movie_curve = (double)
					(bframe_total + pframe_total + i_total) /
					(desired - start_curved - end_curved);

				break;

			case CREDITS_MODE_QUANT :

				// movie curve = (total - credits) / (desired_size - credits)
				twopass.movie_curve = (double)
					(bframe_total + pframe_total + i_total) / (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 = (double)
					(start / 1024) / config.credits_size_start;

				// end curve = (end / end desired size)
				twopass.credits_end_curve = (double)
					(end / 1024) / config.credits_size_end;

				start_curved = (int64_t)(start / twopass.credits_start_curve);
				end_curved = (int64_t)(end / twopass.credits_end_curve);

				// movie curve = (total - credits) / (desired_size - curved credits)
				twopass.movie_curve = (double)
					(bframe_total + pframe_total + i_total) /
					(desired - start_curved - end_curved);

				break;
			}

			if (bframes)
				twopass.average_bframe = (double)bframe_total / bframes / twopass.movie_curve;

			if (pframes)
				twopass.average_pframe = (double)pframe_total / pframes / twopass.movie_curve;
			else
				if (bframes)
					twopass.average_pframe = twopass.average_bframe;  // b-frame packed bitstream fix
				else
				{
					DEBUGERR(_l("ERROR:  No p-frames or b-frames were present in the 1st pass.  Rate control cannot function properly!"));
					return ICERR_ERROR;
				}



			// perform prepass to compensate for over/undersizing
			frames = 0;

			if (config.use_alt_curve)
			{
				twopass.alt_curve_low = twopass.average_pframe - twopass.average_pframe * (double)config.alt_curve_low_dist / 100.0;
				twopass.alt_curve_low_diff = twopass.average_pframe - twopass.alt_curve_low;
				twopass.alt_curve_high = twopass.average_pframe + twopass.average_pframe * (double)config.alt_curve_high_dist / 100.0;
				twopass.alt_curve_high_diff = twopass.alt_curve_high - twopass.average_pframe;
				if (config.alt_curve_use_auto)
				{
					if (twopass.movie_curve > 1.0)
					{
						config.alt_curve_min_rel_qual = (int)(100.0 - (100.0 - 100.0 / twopass.movie_curve) * (double)config.alt_curve_auto_str / 100.0);
						if (config.alt_curve_min_rel_qual < 20)
							config.alt_curve_min_rel_qual = 20;
					}
					else
						config.alt_curve_min_rel_qual = 100;
				}
				twopass.alt_curve_mid_qual = (1.0 + (double)config.alt_curve_min_rel_qual / 100.0) / 2.0;
				twopass.alt_curve_qual_dev = 1.0 - twopass.alt_curve_mid_qual;
				if (config.alt_curve_low_dist > 100)
				{
					switch(config.alt_curve_type)
					{
					case 2: // Sine Curve (high aggressiveness)
						twopass.alt_curve_qual_dev *= 2.0 / (1.0 + 
							sin(DEG2RAD * (twopass.average_pframe * 90.0 / twopass.alt_curve_low_diff)));
						twopass.alt_curve_mid_qual = 1.0 - twopass.alt_curve_qual_dev *
							sin(DEG2RAD * (twopass.average_pframe * 90.0 / twopass.alt_curve_low_diff));
						break;
					case 1: // Linear (medium aggressiveness)
						twopass.alt_curve_qual_dev *= 2.0 / (1.0 +
							twopass.average_pframe / twopass.alt_curve_low_diff);
						twopass.alt_curve_mid_qual = 1.0 - twopass.alt_curve_qual_dev *
							twopass.average_pframe / 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_pframe * 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_pframe * 90.0 / twopass.alt_curve_low_diff)));
					}
				}
			}

			while (1)
			{
				if (twopass.nns_array_pos >= twopass.nns_array_length)
				{
					twopass.nns_array_pos = 0;
					break;
				}

				memcpy(&twopass.nns1, &twopass.nns1_array[twopass.nns_array_pos], sizeof(NNSTATS));
				twopass.nns_array_pos++;

				if (frames == 0)
				{
					twopass.minbsize = (twopass.nns1.kblk + 88) / 8;
					twopass.minpsize = (twopass.nns1.kblk + 88) / 8;
					twopass.minisize = ((twopass.nns1.kblk * 22) + 240) / 8;
					if (recminbsize > twopass.minbsize)
						twopass.minbsize = recminbsize;
					if (recminpsize > twopass.minpsize)
						twopass.minpsize = recminpsize;
					if (recminisize > twopass.minisize)
						twopass.minisize = recminisize;
				}

				// skip unnecessary frames.
				if (twopass.nns1.dd_v & NNSTATS_SKIPFRAME ||
					twopass.nns1.dd_v & NNSTATS_PADFRAME ||
					twopass.nns1.dd_v & NNSTATS_DELAYFRAME)
					continue;

				if (!codec_is_in_credits( frames) &&
					!(twopass.nns1.quant & NNSTATS_KEYFRAME))
				{
					dbytes = twopass.nns1.bytes / twopass.movie_curve;
					total1 += dbytes;

					if (twopass.nns1.dd_v & NNSTATS_BFRAME)
						dbytes *= twopass.average_pframe / twopass.average_bframe;

					if (config.use_alt_curve)
					{
						if (dbytes > twopass.average_pframe)
						{
							if (dbytes >= twopass.alt_curve_high)
								dbytes2 = dbytes * (twopass.alt_curve_mid_qual - twopass.alt_curve_qual_dev);
							else
							{
								switch(config.alt_curve_type)
								{
								case 2:
								dbytes2 = dbytes * (twopass.alt_curve_mid_qual - twopass.alt_curve_qual_dev *
									sin(DEG2RAD * ((dbytes - twopass.average_pframe) * 90.0 / twopass.alt_curve_high_diff)));
									break;
								case 1:
								dbytes2 = dbytes * (twopass.alt_curve_mid_qual - twopass.alt_curve_qual_dev *
									(dbytes - twopass.average_pframe) / twopass.alt_curve_high_diff);
									break;
								case 0:
								dbytes2 = dbytes * (twopass.alt_curve_mid_qual - twopass.alt_curve_qual_dev *
									(1.0 - cos(DEG2RAD * ((dbytes - twopass.average_pframe) * 90.0 / twopass.alt_curve_high_diff))));
								}
							}
						}
						else
						{
							if (dbytes <= twopass.alt_curve_low)
								dbytes2 = dbytes;
							else
							{
								switch(config.alt_curve_type)
								{
								case 2:
								dbytes2 = dbytes * (twopass.alt_curve_mid_qual - twopass.alt_curve_qual_dev *
									sin(DEG2RAD * ((dbytes - twopass.average_pframe) * 90.0 / twopass.alt_curve_low_diff)));
									break;
								case 1:
								dbytes2 = dbytes * (twopass.alt_curve_mid_qual - twopass.alt_curve_qual_dev *
									(dbytes - twopass.average_pframe) / twopass.alt_curve_low_diff);
									break;
								case 0:
								dbytes2 = dbytes * (twopass.alt_curve_mid_qual + twopass.alt_curve_qual_dev *
									(1.0 - cos(DEG2RAD * ((dbytes - twopass.average_pframe) * 90.0 / twopass.alt_curve_low_diff))));
								}
							}
						}
					}
					else
					{
						if (dbytes > twopass.average_pframe)
						{
							dbytes2 = ((double)dbytes + (twopass.average_pframe - dbytes) *
								config.curve_compression_high / 100.0);
						}
						else
						{
							dbytes2 = ((double)dbytes + (twopass.average_pframe - dbytes) *
								config.curve_compression_low / 100.0);
						}
					}

					if (twopass.nns1.dd_v & NNSTATS_BFRAME)
					{
						dbytes2 *= twopass.average_bframe / twopass.average_pframe;
						if (dbytes2 < twopass.minbsize)
							dbytes2 = twopass.minbsize;
					}
					else
					{
						if (dbytes2 < twopass.minpsize)
							dbytes2 = twopass.minpsize;
					}

					total2 += dbytes2;
				}

				++frames;
			}

			twopass.curve_comp_scale = total1 / total2;

			if (!config.use_alt_curve)
			{
				int asymmetric_average_frame;
				char_t s[100];

				asymmetric_average_frame = (int)(twopass.average_pframe * twopass.curve_comp_scale);
				wsprintf(s, _l("middle frame size for asymmetric curve compression: %i"), asymmetric_average_frame);
				DEBUG2P(s);
			}
		}

		if (config.use_alt_curve)
		{
			if (config.alt_curve_use_auto_bonus_bias)
				config.alt_curve_bonus_bias = config.alt_curve_min_rel_qual;

			twopass.curve_bias_bonus = (total1 - total2) * (double)config.alt_curve_bonus_bias / 100.0 / (double)(frames - credits_frames - i_frames);
			twopass.curve_comp_scale = ((total1 - total2) * (1.0 - (double)config.alt_curve_bonus_bias / 100.0) + total2) / total2;


			// special info for alt curve:  bias bonus and quantizer thresholds, 
			{
				double curve_temp, dbytes;
				char_t s[100];
				int i, newquant, percent;
				int oldquant = 1;

				wsprintf(s, _l("avg scaled framesize:%i"), (int)(twopass.average_pframe));
				DEBUG2P(s);

				wsprintf(s, _l("bias bonus:%i bytes"), (int)(twopass.curve_bias_bonus));
				DEBUG2P(s);

				for (i=1; i <= (int)(twopass.alt_curve_high*2)+1; i++)
				{
					dbytes = i;
					if (dbytes > twopass.average_pframe)
					{
						if (dbytes >= twopass.alt_curve_high)
							curve_temp = dbytes * (twopass.alt_curve_mid_qual - twopass.alt_curve_qual_dev);
						else
						{
							switch(config.alt_curve_type)
							{
							case 2:
							curve_temp = dbytes * (twopass.alt_curve_mid_qual - twopass.alt_curve_qual_dev *
								sin(DEG2RAD * ((dbytes - twopass.average_pframe) * 90.0 / twopass.alt_curve_high_diff)));
								break;
							case 1:
							curve_temp = dbytes * (twopass.alt_curve_mid_qual - twopass.alt_curve_qual_dev *