Changed video bitrate calculation to use HandbrakeInterop rather than the core handbrake function, since hb_calc_bitrate is going away soon. Also added a function to predict file size and cleaned up control visibility for different video rate types.

Author: RandomEngy

HandBrakeInterop/HandBrakeInterop/HandBrakeInstance.cs

@@ -80,7 +80,7 @@ public class HandBrakeInstance : IDisposable
 		/// <summary>
 		/// The current encode job for this instance.
 		/// </summary>
-		private EncodeJob job;
+		private EncodeJob currentJob;
 
 		/// <summary>
 		/// True if the current job is scanning for subtitles.
@@ -288,16 +288,80 @@ public BitmapImage GetPreview(EncodeJob job, int previewNumber)
 		/// <returns>The video bitrate in kbps.</returns>
 		public int CalculateBitrate(EncodeJob job, int sizeMB)
 		{
-			hb_title_s title = this.GetOriginalTitle(job.Title);
+			long availableBytes = sizeMB * 1024 * 1024;
 
-			hb_job_s nativeJob = InteropUtilities.ReadStructure<hb_job_s>(title.job);
-			List<IntPtr> allocatedMemory = this.ApplyJob(ref nativeJob, job);
+			EncodingProfile profile = job.EncodingProfile;
+			Title title = this.GetTitle(job.Title);
 
-			int calculatedBitrate = HbLib.hb_calc_bitrate(ref nativeJob, sizeMB);
+			double lengthSeconds = HandBrakeUtils.GetJobLengthSeconds(job, title);
+			lengthSeconds += 1.5;
 
-			InteropUtilities.FreeMemory(allocatedMemory);
+			double outputFramerate;
+			if (profile.Framerate == 0)
+			{
+				outputFramerate = title.Framerate;
+			}
+			else
+			{
+				// Not sure what to do for VFR here hb_calc_bitrate never handled it...
+				//   just use the peak for now.
+				outputFramerate = profile.Framerate;
+			}
+
+			long frames = (long)(lengthSeconds * outputFramerate);
+
+			availableBytes -= frames * HandBrakeUtils.ContainerOverheadPerFrame;
+
+			List<Tuple<AudioEncoding, int>> outputTrackList = this.GetOutputTracks(job);
+			availableBytes -= HandBrakeUtils.GetAudioSize(job, lengthSeconds, title, outputTrackList);
+
+			if (availableBytes < 0)
+			{
+				return 0;
+			}
 
-			return calculatedBitrate;
+			// Video bitrate is in kilobits per second, or where 1 kbps is 1000 bits per second.
+			// So 1 kbps is 125 bytes per second.
+			return (int)(availableBytes / (125 * lengthSeconds));
+		}
+
+		/// <summary>
+		/// Gives estimated file size (in MB) of the given job and video bitrate.
+		/// </summary>
+		/// <param name="job">The encode job.</param>
+		/// <param name="videoBitrate">The video bitrate to be used (kbps).</param>
+		/// <returns>The estimated file size (in MB) of the given job and video bitrate.</returns>
+		public double CalculateFileSize(EncodeJob job, int videoBitrate)
+		{
+			long totalBytes = 0;
+
+			EncodingProfile profile = job.EncodingProfile;
+			Title title = this.GetTitle(job.Title);
+
+			double lengthSeconds = HandBrakeUtils.GetJobLengthSeconds(job, title);
+			lengthSeconds += 1.5;
+
+			double outputFramerate;
+			if (profile.Framerate == 0)
+			{
+				outputFramerate = title.Framerate;
+			}
+			else
+			{
+				// Not sure what to do for VFR here hb_calc_bitrate never handled it...
+				//   just use the peak for now.
+				outputFramerate = profile.Framerate;
+			}
+
+			long frames = (long)(lengthSeconds * outputFramerate);
+
+			totalBytes += (long)(lengthSeconds * videoBitrate * 125);
+			totalBytes += frames * HandBrakeUtils.ContainerOverheadPerFrame;
+
+			List<Tuple<AudioEncoding, int>> outputTrackList = this.GetOutputTracks(job);
+			totalBytes += HandBrakeUtils.GetAudioSize(job, lengthSeconds, title, outputTrackList);
+
+			return (double)totalBytes / 1024 / 1024;
 		}
 
 		/// <summary>
@@ -318,7 +382,7 @@ public void StartEncode(EncodeJob jobToStart)
 		/// <param name="previewSeconds">The number of seconds in the preview.</param>
 		public void StartEncode(EncodeJob job, bool preview, int previewNumber, int previewSeconds)
 		{
-			this.job = job;
+			this.currentJob = job;
 			hb_job_s nativeJob = InteropUtilities.ReadStructure<hb_job_s>(this.GetOriginalTitle(job.Title).job);
 			this.encodeAllocatedMemory = this.ApplyJob(ref nativeJob, job, preview, previewNumber, previewSeconds);
 
@@ -484,7 +548,7 @@ public void GetSize(EncodeJob job, out int width, out int height, out int parWid
 				return;
 			}
 
-			hb_job_s nativeJob = InteropUtilities.ReadStructure<hb_job_s>(this.GetOriginalTitle(job.Title).job);
+			var nativeJob = InteropUtilities.ReadStructure<hb_job_s>(this.GetOriginalTitle(job.Title).job);
 			List<IntPtr> allocatedMemory = this.ApplyJob(ref nativeJob, job, false, 0, 0);
 
 			int refWidth = 0;
@@ -541,7 +605,7 @@ protected virtual void Dispose(bool disposing)
 		/// </summary>
 		private void PollScanProgress()
 		{
-			hb_state_s state = new hb_state_s();
+			var state = new hb_state_s();
 			HbLib.hb_get_state(this.hbHandle, ref state);
 
 			if (state.state == NativeConstants.HB_STATE_SCANNING)
@@ -568,7 +632,7 @@ private void PollScanProgress()
 
 				if (this.originalTitles.Count > 0)
 				{
-					hb_job_s nativeJob = InteropUtilities.ReadStructure<hb_job_s>(this.originalTitles[0].job);
+					var nativeJob = InteropUtilities.ReadStructure<hb_job_s>(this.originalTitles[0].job);
 					this.featureTitle = nativeJob.feature;
 				}
 				else
@@ -600,7 +664,7 @@ private void PollEncodeProgress()
 					int pass = 1;
 					int rawJobNumber = state.param.working.job_cur;
 
-					if (this.job.EncodingProfile.TwoPass)
+					if (this.currentJob.EncodingProfile.TwoPass)
 					{
 						if (this.subtitleScan)
 						{
@@ -995,25 +1059,12 @@ private List<IntPtr> ApplyJob(ref hb_job_s nativeJob, EncodeJob job, bool previe
 
 			var audioList = new List<hb_audio_s>();
 			int numTracks = 0;
-			foreach (AudioEncoding encoding in profile.AudioEncodings)
+
+			List<Tuple<AudioEncoding, int>> outputTrackList = this.GetOutputTracks(job);
+
+			foreach (Tuple<AudioEncoding, int> outputTrack in outputTrackList)
 			{
-				if (encoding.InputNumber == 0)
-				{
-					// Add this encoding for all chosen tracks
-					foreach (int chosenTrack in job.ChosenAudioTracks)
-					{
-						if (titleAudio.Count >= chosenTrack)
-						{
-							audioList.Add(ConvertAudioBack(encoding, titleAudio[chosenTrack - 1], chosenTrack, numTracks++, allocatedMemory));
-						}
-					}
-				}
-				else if (encoding.InputNumber <= job.ChosenAudioTracks.Count)
-				{
-					// Add this encoding for the specified track, if it exists
-					int trackNumber = job.ChosenAudioTracks[encoding.InputNumber - 1];
-					audioList.Add(ConvertAudioBack(encoding, titleAudio[trackNumber - 1], trackNumber, numTracks++, allocatedMemory));
-				}
+				audioList.Add(ConvertAudioBack(outputTrack.Item1, titleAudio[outputTrack.Item2 -1], outputTrack.Item2, numTracks++, allocatedMemory));
 			}
 
 			NativeList nativeAudioList = InteropUtilities.ConvertListBack<hb_audio_s>(audioList);
@@ -1152,6 +1203,36 @@ private List<IntPtr> ApplyJob(ref hb_job_s nativeJob, EncodeJob job, bool previe
 			return allocatedMemory;
 		}
 
+		/// <summary>
+		/// Gets a list of encodings and target track indices (1-based).
+		/// </summary>
+		/// <param name="job">The encode job</param>
+		/// <returns>A list of encodings and target track indices (1-based).</returns>
+		private List<Tuple<AudioEncoding, int>> GetOutputTracks(EncodeJob job)
+		{
+			var list = new List<Tuple<AudioEncoding, int>>();
+
+			foreach (AudioEncoding encoding in job.EncodingProfile.AudioEncodings)
+			{
+				if (encoding.InputNumber == 0)
+				{
+					// Add this encoding for all chosen tracks
+					foreach (int chosenTrack in job.ChosenAudioTracks)
+					{
+						list.Add(new Tuple<AudioEncoding, int>(encoding, chosenTrack));
+					}
+				}
+				else if (encoding.InputNumber <= job.ChosenAudioTracks.Count)
+				{
+					// Add this encoding for the specified track, if it exists
+					int trackNumber = job.ChosenAudioTracks[encoding.InputNumber - 1];
+					list.Add(new Tuple<AudioEncoding, int>(encoding, trackNumber));
+				}
+			}
+
+			return list;
+		}
+
 		/// <summary>
 		/// Adds a filter to the given filter list.
 		/// </summary>
@@ -1373,7 +1454,8 @@ private Title ConvertTitle(hb_title_s title)
 					LanguageCode = audio.config.lang.iso639_2,
 					Description = audio.config.lang.description,
 					ChannelLayout = audio.config.input.channel_layout,
-					SampleRate = audio.config.input.samplerate
+					SampleRate = audio.config.input.samplerate,
+					Bitrate = audio.config.input.bitrate
 				};
 
 				newTitle.AudioTracks.Add(newAudio);

HandBrakeInterop/HandBrakeInterop/HandBrakeUtils.cs

@@ -2,11 +2,17 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
+using HandBrake.SourceData;
 
 namespace HandBrake.Interop
 {
 	public static class HandBrakeUtils
 	{
+		/// <summary>
+		/// Estimated overhead in bytes for each frame in output container.
+		/// </summary>
+		internal const int ContainerOverheadPerFrame = 6;
+
 		/// <summary>
 		/// The callback for log messages from HandBrake.
 		/// </summary>
@@ -138,5 +144,100 @@ public static int SanitizeAudioBitrate(int audioBitrate, AudioEncoder encoder, i
 		{
 			return HbLib.hb_get_best_audio_bitrate(Converters.AudioEncoderToNative(encoder), audioBitrate, sampleRate, Converters.MixdownToNative(mixdown));
 		}
+
+		/// <summary>
+		/// Gets the total number of seconds on the given encode job.
+		/// </summary>
+		/// <param name="job">The encode job to query.</param>
+		/// <param name="title">The title being encoded.</param>
+		/// <returns>The total number of seconds of video to encode.</returns>
+		internal static double GetJobLengthSeconds(EncodeJob job, Title title)
+		{
+			switch (job.RangeType)
+			{
+				case VideoRangeType.Chapters:
+					TimeSpan duration = TimeSpan.Zero;
+					for (int i = job.ChapterStart; i <= job.ChapterEnd; i++)
+					{
+						duration += title.Chapters[i - 1].Duration;
+					}
+
+					return duration.TotalSeconds;
+				case VideoRangeType.Seconds:
+					return job.SecondsEnd - job.SecondsStart;
+				case VideoRangeType.Frames:
+					return (job.FramesEnd - job.FramesStart) / title.Framerate;
+			}
+
+			return 0;
+		}
+
+		/// <summary>
+		/// Gets the number of audio samples used per frame for the given audio encoder.
+		/// </summary>
+		/// <param name="encoder">The encoder to query.</param>
+		/// <returns>The number of audio samples used per frame for the given
+		/// audio encoder.</returns>
+		internal static int GetAudioSamplesPerFrame(AudioEncoder encoder)
+		{
+			switch (encoder)
+			{
+				case AudioEncoder.Faac:
+				case AudioEncoder.Vorbis:
+					return 1024;
+				case AudioEncoder.Lame:
+					return 1152;
+				case AudioEncoder.Ac3:
+				case AudioEncoder.Passthrough:
+				case AudioEncoder.Ac3Passthrough:
+				case AudioEncoder.DtsPassthrough:
+					return 1536;
+			}
+
+			System.Diagnostics.Debug.Assert(true, "Audio encoder unrecognized.");
+			return 0;
+		}
+
+		/// <summary>
+		/// Gets the size in bytes for the audio with the given parameters.
+		/// </summary>
+		/// <param name="job">The encode job.</param>
+		/// <param name="lengthSeconds">The length of the encode in seconds.</param>
+		/// <param name="title">The title to encode.</param>
+		/// <param name="outputTrackList">The list of tracks to encode.</param>
+		/// <returns>The size in bytes for the audio with the given parameters.</returns>
+		internal static long GetAudioSize(EncodeJob job, double lengthSeconds, Title title, List<Tuple<AudioEncoding, int>> outputTrackList)
+		{
+			long audioBytes = 0;
+
+			foreach (Tuple<AudioEncoding, int> outputTrack in outputTrackList)
+			{
+				AudioEncoding encoding = outputTrack.Item1;
+				AudioTrack track = title.AudioTracks[outputTrack.Item2 - 1];
+
+				int samplesPerFrame = HandBrakeUtils.GetAudioSamplesPerFrame(encoding.Encoder);
+				int audioBitrate;
+
+				if (encoding.Encoder == AudioEncoder.Passthrough ||
+					encoding.Encoder == AudioEncoder.Ac3Passthrough ||
+					encoding.Encoder == AudioEncoder.DtsPassthrough)
+				{
+					// Input bitrate is in bits/second.
+					audioBitrate = track.Bitrate / 8;
+				}
+				else
+				{
+					// Output bitrate is in kbps.
+					audioBitrate = encoding.Bitrate * 1000 / 8;
+				}
+
+				audioBytes += (long)(lengthSeconds * audioBitrate);
+
+				// Audio overhead
+				audioBytes += encoding.SampleRateRaw * ContainerOverheadPerFrame / samplesPerFrame;
+			}
+
+			return audioBytes;
+		}
 	}
 }

HandBrakeInterop/HandBrakeInterop/Model/Encoding/AudioEncoding.cs

@@ -9,6 +9,10 @@ public class AudioEncoding
 	{
 		public int InputNumber { get; set; }
 		public AudioEncoder Encoder { get; set; }
+
+		/// <summary>
+		/// Gets or sets the bitrate (in kbps) of this track.
+		/// </summary>
 		public int Bitrate { get; set; }
 		public Mixdown Mixdown { get; set; }
 

HandBrakeInterop/HandBrakeInterop/SourceData/AudioTrack.cs

@@ -46,7 +46,7 @@ public class AudioTrack
 		public int SampleRate { get; set; }
 
 		/// <summary>
-		/// The bitrate (in kbps) of this Audio Track
+		/// The bitrate (in bits/sec) of this Audio Track.
 		/// </summary>
 		public int Bitrate { get; set; }
 

VidCoder/App.xaml

@@ -6,6 +6,8 @@
 		<converters:VisibilityConverter x:Key="VisibilityConverter" />
 		<converters:EnumBoolConverter x:Key="EnumBoolConverter" />
 		<converters:EnumBoolInverseConverter x:Key="EnumBoolInverseConverter" />
+		<converters:EnumVisibilityConverter x:Key="EnumVisibilityConverter" />
+		<converters:EnumVisibilityInverseConverter x:Key="EnumVisibilityInverseConverter" />
 		<converters:InverseBoolConverter x:Key="InverseBoolConverter" />
 		<converters:PercentDisplayConverter x:Key="PercentDisplayConverter" />
 		<converters:DoubleDisplayConverter x:Key="DoubleDisplayConverter" />

VidCoder/Converters/EnumVisibilityConverter.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using System.Windows;
+using System.Windows.Data;
+
+namespace VidCoder.Converters
+{
+	public class EnumVisibilityConverter : IValueConverter
+	{
+		public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
+		{
+			return string.Compare(value.ToString(), (string)parameter, StringComparison.InvariantCultureIgnoreCase) == 0 ? Visibility.Visible : Visibility.Collapsed;
+		}
+
+		public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
+		{
+			return null;
+		}
+	}
+}