private SourceAudioTrack GetTargetAudioTrack()
{
if (this.main.SelectedTitle == null)
{
return(null);
}
SourceAudioTrack track = null;
List <int> chosenAudioTracks = this.main.GetChosenAudioTracks();
if (this.TargetStreamIndex > 0 && this.TargetStreamIndex <= chosenAudioTracks.Count)
{
int audioTrack = chosenAudioTracks[this.TargetStreamIndex - 1];
if (audioTrack <= this.main.SelectedTitle.AudioList.Count)
{
track = this.main.SelectedTitle.AudioList[audioTrack - 1];
}
}
if (this.TargetStreamIndex == 0 && chosenAudioTracks.Count == 1)
{
int audioTrack = chosenAudioTracks[0];
if (audioTrack <= this.main.SelectedTitle.AudioList.Count)
{
track = this.main.SelectedTitle.AudioList[audioTrack - 1];
}
}
return(track);
}
public static OutputAudioTrackInfo GetDefaultSettings(SourceAudioTrack source, HBAudioEncoder encoder)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (encoder == null)
{
throw new ArgumentNullException(nameof(encoder));
}
var result = new OutputAudioTrackInfo
{
Encoder = encoder,
Drc = 0,
Gain = 0,
SampleRate = HandBrakeEncoderHelpers.SanitizeSampleRate(encoder, source.SampleRate)
};
if (encoder.SupportsCompression)
{
result.CompressionLevel = HandBrakeEncoderHelpers.GetDefaultAudioCompression(encoder);
}
HBMixdown mixdown = HandBrakeEncoderHelpers.GetDefaultMixdown(encoder, (ulong)source.ChannelLayout);
result.Mixdown = mixdown;
// For some reason HB does not honor Quality when falling back to an encoder during auto-passthrough.
// For now we do bitrate only.
//if (encoder.SupportsQuality)
//{
// result.EncodeRateType = AudioEncodeRateType.Quality;
// result.Quality = HandBrakeEncoderHelpers.GetDefaultQuality(encoder);
//}
//else
//{
result.EncodeRateType = AudioEncodeRateType.Bitrate;
result.Bitrate = HandBrakeEncoderHelpers.GetDefaultBitrate(encoder, result.SampleRate, mixdown);
//}
return(result);
}
private void RefreshMixdownChoices()
{
HBMixdown oldMixdown = null;
if (this.SelectedMixdown != null)
{
oldMixdown = this.SelectedMixdown.Mixdown;
}
this.mixdownChoices = new List <MixdownViewModel>();
HBAudioEncoder hbAudioEncoder = this.HBAudioEncoder;
foreach (HBMixdown mixdown in HandBrakeEncoderHelpers.Mixdowns)
{
// Only add option if codec supports the mixdown
if (HandBrakeEncoderHelpers.MixdownHasCodecSupport(mixdown, hbAudioEncoder))
{
// Determine compatibility of mixdown with the input channel layout
// Incompatible mixdowns are grayed out
bool isCompatible = true;
if (this.main.HasVideoSource)
{
SourceAudioTrack track = this.GetTargetAudioTrack();
if (track != null)
{
isCompatible = HandBrakeEncoderHelpers.MixdownHasRemixSupport(mixdown, (ulong)track.ChannelLayout);
}
}
this.MixdownChoices.Add(new MixdownViewModel {
Mixdown = mixdown, IsCompatible = isCompatible
});
}
}
this.RaisePropertyChanged(nameof(this.MixdownChoices));
this.SelectMixdown(oldMixdown);
this.RaisePropertyChanged(nameof(this.SelectedMixdown));
}
/// <summary>
/// Creates an instance of the AudioTrackViewModel class.
/// </summary>
/// <param name="audioTrack">The audio track to wrap.</param>
/// <param name="trackNumber">The (1-based) track number.</param>
public AudioTrackViewModel(SourceAudioTrack audioTrack, int trackNumber)
{
this.AudioTrack = audioTrack;
this.trackNumber = trackNumber;
}
public AudioOutputPreview GetAudioPreview(SourceAudioTrack inputTrack, AudioEncodingViewModel audioVM)
{
HBAudioEncoder encoder = audioVM.HBAudioEncoder;
var outputPreviewTrack = new AudioOutputPreview
{
Name = inputTrack.Description,
Encoder = encoder.DisplayName
};
if (encoder.IsPassthrough)
{
// For passthrough encodes, we need to make sure the input track is of the right type
if (!HandBrakeEncoderHelpers.AudioEncoderIsCompatible(inputTrack.Codec, encoder) && encoder.ShortName != "copy")
{
return(null);
}
}
if (encoder.ShortName == "copy")
{
if (this.copyMaskChoices.Items.Any(
choice =>
{
if (!choice.Enabled)
{
return(false);
}
return((HandBrakeEncoderHelpers.GetAudioEncoder("copy:" + choice.Codec).Id & inputTrack.Codec) > 0);
}))
{
return(outputPreviewTrack);
}
if (this.Profile.AudioEncoderFallback == null)
{
encoder = HandBrakeEncoderHelpers.AudioEncoders.First(a => !a.IsPassthrough);
}
else
{
// The fallback is explicitly set to "None", so drop the track.
if (this.Profile.AudioEncoderFallback == "none")
{
return(null);
}
encoder = HandBrakeEncoderHelpers.GetAudioEncoder(this.Profile.AudioEncoderFallback);
}
// Get the default output values for the input track and encoder
var defaultSettings = AudioUtilities.GetDefaultSettings(inputTrack, encoder);
// Apply the output values to the preview object
UpdateAudioPreviewTrack(outputPreviewTrack, defaultSettings);
}
else
{
HBMixdown previewMixdown;
previewMixdown = HandBrakeEncoderHelpers.SanitizeMixdown(audioVM.SelectedMixdown.Mixdown, encoder, (ulong)inputTrack.ChannelLayout);
int previewSampleRate = audioVM.SampleRate;
if (previewSampleRate == 0)
{
previewSampleRate = inputTrack.SampleRate;
}
// Collect the output values in the AudioTrack object
var outputTrack = new OutputAudioTrackInfo
{
Encoder = encoder,
Mixdown = previewMixdown,
SampleRate = HandBrakeEncoderHelpers.SanitizeSampleRate(encoder, previewSampleRate),
EncodeRateType = audioVM.EncodeRateType
};
if (audioVM.EncodeRateType == AudioEncodeRateType.Bitrate)
{
int previewBitrate = audioVM.SelectedBitrate.Bitrate;
if (previewBitrate == 0)
{
previewBitrate = HandBrakeEncoderHelpers.GetDefaultBitrate(encoder, previewSampleRate, previewMixdown);
}
else
{
previewBitrate = HandBrakeEncoderHelpers.SanitizeAudioBitrate(previewBitrate, encoder, previewSampleRate, previewMixdown);
}
outputTrack.Bitrate = previewBitrate;
}
else
{
outputTrack.Quality = audioVM.AudioQuality;
}
outputTrack.Gain = audioVM.Gain;
outputTrack.Drc = audioVM.Drc;
// Apply the output values to the preview object
UpdateAudioPreviewTrack(outputPreviewTrack, outputTrack);
}
return(outputPreviewTrack);
}
/// <summary>
/// Creates an instance of the AudioTrackViewModel class.
/// </summary>
/// <param name="mainViewModel">An instance of the main viewmodel.</param>
/// <param name="audioTrack">The audio track to wrap.</param>
/// <param name="trackNumber">The (1-based) track number.</param>
public AudioTrackViewModel(MainViewModel mainViewModel, SourceAudioTrack audioTrack, int trackNumber)
{
this.mainViewModel = mainViewModel;
this.AudioTrack = audioTrack;
this.TrackNumber = trackNumber;
}
public AudioOutputPreview GetAudioPreview(SourceAudioTrack inputTrack, AudioEncodingViewModel audioVM)
{
HBAudioEncoder encoder = audioVM.HBAudioEncoder;
var outputPreviewTrack = new AudioOutputPreview
{
Name = inputTrack.Description,
Encoder = encoder.DisplayName
};
if (encoder.IsPassthrough)
{
// For passthrough encodes, we need to make sure the input track is of the right type
if (!HandBrakeEncoderHelpers.AudioEncoderIsCompatible(inputTrack.Codec, encoder) && encoder.ShortName != "copy")
{
return(null);
}
}
// Find out what the real mixdown, sample rate and bitrate will be.
HBMixdown mixdown;
int sampleRate, bitrate;
if (encoder.ShortName == "copy")
{
if (this.CopyMaskChoices.Any(
choice =>
{
if (!choice.Enabled)
{
return(false);
}
return((HandBrakeEncoderHelpers.GetAudioEncoder("copy:" + choice.Codec).Id & inputTrack.Codec) > 0);
}))
{
return(outputPreviewTrack);
}
if (this.Profile.AudioEncoderFallback == null)
{
encoder = HandBrakeEncoderHelpers.AudioEncoders.First(a => !a.IsPassthrough);
}
else
{
encoder = HandBrakeEncoderHelpers.GetAudioEncoder(this.Profile.AudioEncoderFallback);
}
mixdown = HandBrakeEncoderHelpers.GetDefaultMixdown(encoder, (ulong)inputTrack.ChannelLayout);
sampleRate = 0;
bitrate = 0;
outputPreviewTrack.Encoder = encoder.DisplayName;
}
else
{
mixdown = audioVM.SelectedMixdown.Mixdown;
sampleRate = audioVM.SampleRate;
bitrate = audioVM.SelectedBitrate.Bitrate;
}
HBMixdown previewMixdown;
previewMixdown = HandBrakeEncoderHelpers.SanitizeMixdown(mixdown, encoder, (ulong)inputTrack.ChannelLayout);
int previewSampleRate = sampleRate;
if (previewSampleRate == 0)
{
previewSampleRate = inputTrack.SampleRate;
}
int previewBitrate = bitrate;
if (previewBitrate == 0)
{
previewBitrate = HandBrakeEncoderHelpers.GetDefaultBitrate(encoder, previewSampleRate, previewMixdown);
}
else
{
previewBitrate = HandBrakeEncoderHelpers.SanitizeAudioBitrate(previewBitrate, encoder, previewSampleRate, previewMixdown);
}
outputPreviewTrack.Mixdown = previewMixdown.DisplayName;
outputPreviewTrack.SampleRate = DisplayConversions.DisplaySampleRate(previewSampleRate);
if (audioVM.EncodeRateType == AudioEncodeRateType.Bitrate)
{
if (previewBitrate >= 0)
{
outputPreviewTrack.Quality = previewBitrate + " kbps";
}
else
{
outputPreviewTrack.Quality = string.Empty;
}
}
else
{
outputPreviewTrack.Quality = "CQ " + audioVM.AudioQuality;
}
var modifiers = new List <string>();
if (audioVM.Gain != 0)
{
modifiers.Add(string.Format("{0}{1} dB", audioVM.Gain > 0 ? "+" : string.Empty, audioVM.Gain));
}
if (audioVM.Drc != 0)
{
modifiers.Add("DRC " + audioVM.Drc.ToString());
}
outputPreviewTrack.Modifiers = string.Join(", ", modifiers);
return(outputPreviewTrack);
}
