public SubtitleDialogViewModel(Subtitles currentSubtitles)
{
this.container = Encoders.GetContainer(this.presetsViewModel.SelectedPreset.Preset.EncodingProfile.ContainerName);
this.sourceSubtitles = new ObservableCollection <SourceSubtitleViewModel>();
this.srtSubtitles = new ObservableCollection <SrtSubtitleViewModel>();
if (currentSubtitles != null)
{
if (!currentSubtitles.SourceSubtitles.Any(s => s.TrackNumber == 0))
{
this.sourceSubtitles.Add(
new SourceSubtitleViewModel(
this,
new SourceSubtitle
{
TrackNumber = 0,
BurnedIn = false,
Forced = false,
Default = false
}));
}
foreach (SourceSubtitle subtitle in currentSubtitles.SourceSubtitles)
{
this.sourceSubtitles.Add(new SourceSubtitleViewModel(this, subtitle.Clone())
{
Selected = true
});
}
foreach (SrtSubtitle subtitle in currentSubtitles.SrtSubtitles)
{
this.srtSubtitles.Add(new SrtSubtitleViewModel(this, subtitle.Clone()));
}
}
// Fill in remaining unselected source subtitles
foreach (Subtitle subtitle in this.mainViewModel.SelectedTitle.Subtitles)
{
if (!currentSubtitles.SourceSubtitles.Any(s => s.TrackNumber == subtitle.TrackNumber))
{
var newSubtitle = new SourceSubtitle
{
TrackNumber = subtitle.TrackNumber,
Default = false,
Forced = false,
BurnedIn = false
};
this.sourceSubtitles.Add(new SourceSubtitleViewModel(this, newSubtitle));
}
}
this.sourceSubtitles.CollectionChanged += this.SourceCollectionChanged;
this.srtSubtitles.CollectionChanged += this.SrtCollectionChanged;
this.UpdateBoxes();
}
public void UpdateWarningVisibility()
{
bool textSubtitleVisible = false;
VCProfile profile = this.presetsViewModel.SelectedPreset.Preset.EncodingProfile;
HBContainer profileContainer = Encoders.GetContainer(profile.ContainerName);
if (profileContainer.DefaultExtension == "mp4" && profile.PreferredExtension == VCOutputExtension.Mp4)
{
foreach (SourceSubtitleViewModel sourceVM in this.SourceSubtitles)
{
if (sourceVM.Selected && sourceVM.SubtitleName.Contains("(Text)"))
{
textSubtitleVisible = true;
break;
}
}
}
this.TextSubtitleWarningVisibile = textSubtitleVisible;
bool anyBurned = false;
int totalTracks = 0;
foreach (SourceSubtitleViewModel sourceVM in this.SourceSubtitles)
{
if (sourceVM.Selected)
{
totalTracks++;
if (sourceVM.BurnedIn)
{
anyBurned = true;
}
}
}
foreach (SrtSubtitleViewModel srtVM in this.SrtSubtitles)
{
totalTracks++;
if (srtVM.BurnedIn)
{
anyBurned = true;
}
}
this.BurnedOverlapWarningVisible = anyBurned && totalTracks > 1;
}
public static string GetExtensionForProfile(VCProfile profile, bool includeDot = true)
{
HBContainer container = Encoders.GetContainer(profile.ContainerName);
string extension;
if (container.DefaultExtension == "mkv")
{
extension = "mkv";
}
else if (container.DefaultExtension == "mp4" && profile.PreferredExtension == VCOutputExtension.Mp4)
{
extension = "mp4";
}
else
{
extension = "m4v";
}
return(includeDot ? "." + extension : extension);
}
private void RefreshEncoderChoices(string containerName, bool applyDefaults)
{
HBContainer container = Encoders.GetContainer(containerName);
HBVideoEncoder oldEncoder = null;
if (this.selectedEncoder != null)
{
oldEncoder = this.selectedEncoder.Encoder;
}
this.encoderChoices = new List <VideoEncoderViewModel>();
foreach (HBVideoEncoder encoder in Encoders.VideoEncoders)
{
if ((encoder.CompatibleContainers & container.Id) > 0)
{
this.EncoderChoices.Add(new VideoEncoderViewModel {
Encoder = encoder
});
}
}
this.RaisePropertyChanged(() => this.EncoderChoices);
this.selectedEncoder = this.EncoderChoices.FirstOrDefault(e => e.Encoder == oldEncoder);
if (this.selectedEncoder == null)
{
this.selectedEncoder = this.EncoderChoices[0];
}
if (this.selectedEncoder.Encoder != oldEncoder)
{
RefreshEncoderSettings(applyDefaults);
this.NotifyEncoderChanged();
}
this.RaisePropertyChanged(() => this.SelectedEncoder);
}
private void RefreshFallbackEncoderChoices()
{
if (this.EncodingViewModel.EncodingProfile == null)
{
return;
}
HBContainer container = Encoders.GetContainer(this.EncodingViewModel.EncodingProfile.ContainerName);
HBAudioEncoder oldEncoder = null;
if (this.selectedFallbackEncoder != null)
{
oldEncoder = this.selectedFallbackEncoder.Encoder;
}
this.fallbackEncoderChoices = new List <AudioEncoderViewModel>();
foreach (HBAudioEncoder encoder in Encoders.AudioEncoders)
{
if ((encoder.CompatibleContainers & container.Id) > 0 && !encoder.IsPassthrough)
{
this.FallbackEncoderChoices.Add(new AudioEncoderViewModel {
Encoder = encoder
});
}
}
this.RaisePropertyChanged(() => this.FallbackEncoderChoices);
this.selectedFallbackEncoder = this.FallbackEncoderChoices.FirstOrDefault(e => e.Encoder == oldEncoder);
if (this.selectedFallbackEncoder == null)
{
this.selectedFallbackEncoder = this.FallbackEncoderChoices[0];
}
this.RaisePropertyChanged(() => this.SelectedFallbackEncoder);
}
private static void ErrorCheckPreset(Preset preset)
{
// mp4v2 only available on x86
string containerName = preset.EncodingProfile.ContainerName;
if (Encoders.GetContainer(containerName) == null)
{
if (containerName == "mp4v2")
{
preset.EncodingProfile.ContainerName = "av_mp4";
}
}
// QSV H.264 only available on systems with the right hardware.
string videoEncoderName = preset.EncodingProfile.VideoEncoder;
if (Encoders.GetVideoEncoder(videoEncoderName) == null)
{
if (videoEncoderName == "qsv_h264")
{
preset.EncodingProfile.VideoEncoder = "x264";
}
}
}
private void RefreshEncoderChoices()
{
HBContainer container = Encoders.GetContainer(this.containerName);
AudioEncoderViewModel oldEncoder = null;
string oldPassthrough = null;
if (this.selectedAudioEncoder != null)
{
oldEncoder = this.selectedAudioEncoder;
oldPassthrough = this.selectedPassthrough;
}
var resourceManager = new ResourceManager(typeof(EncodingRes));
this.audioEncoders = new List <AudioEncoderViewModel>();
this.audioEncoders.Add(new AudioEncoderViewModel {
IsPassthrough = true
});
this.passthroughChoices = new List <ComboChoice>();
this.passthroughChoices.Add(new ComboChoice("copy", EncodingRes.Passthrough_any));
foreach (HBAudioEncoder encoder in Encoders.AudioEncoders)
{
if ((encoder.CompatibleContainers & container.Id) > 0)
{
if (encoder.IsPassthrough)
{
if (encoder.ShortName.Contains(":"))
{
string inputCodec = encoder.ShortName.Split(':')[1];
string display = resourceManager.GetString("Passthrough_" + inputCodec);
this.passthroughChoices.Add(new ComboChoice(encoder.ShortName, display));
}
}
else
{
this.AudioEncoders.Add(new AudioEncoderViewModel {
Encoder = encoder
});
}
}
}
this.RaisePropertyChanged(() => this.AudioEncoders);
this.RaisePropertyChanged(() => this.PassthroughChoices);
if (oldEncoder == null)
{
this.selectedAudioEncoder = this.audioEncoders[1];
}
else
{
if (oldEncoder.IsPassthrough)
{
this.selectedAudioEncoder = this.audioEncoders[0];
this.selectedPassthrough = oldPassthrough;
}
else
{
this.selectedAudioEncoder = this.audioEncoders.Skip(1).FirstOrDefault(e => e.Encoder == oldEncoder.Encoder);
this.selectedPassthrough = "copy";
}
}
if (this.selectedAudioEncoder == null)
{
this.selectedAudioEncoder = this.audioEncoders[1];
}
this.RaisePropertyChanged(() => this.SelectedAudioEncoder);
this.RaisePropertyChanged(() => this.SelectedPassthrough);
this.RaisePropertyChanged(() => this.AutoPassthroughSettingsVisible);
}
public AudioOutputPreview GetAudioPreview(AudioTrack inputTrack, AudioEncodingViewModel audioVM)
{
HBAudioEncoder encoder = audioVM.HBAudioEncoder;
var outputPreviewTrack = new AudioOutputPreview
{
Name = inputTrack.NoTrackDisplay,
Encoder = encoder.DisplayName
};
if (encoder.IsPassthrough)
{
// For passthrough encodes, we need to make sure the input track is of the right type
if (!Encoders.AudioEncoderIsCompatible(inputTrack, encoder) && encoder.ShortName != "copy")
{
return(null);
}
HBContainer container = Encoders.GetContainer(this.Profile.ContainerName);
if (encoder.ShortName == "copy" && (inputTrack.Codec == AudioCodec.Dts || inputTrack.Codec == AudioCodec.DtsHD) && container.DefaultExtension == "mp4")
{
this.PassthroughWarningText = EncodingRes.DtsMp4Warning;
this.PassthroughWarningVisible = true;
return(outputPreviewTrack);
}
}
// Find out what the real mixdown, sample rate and bitrate will be.
HBMixdown mixdown;
int sampleRate, bitrate;
if (encoder.ShortName == "copy")
{
if (Encoders.AudioEncoderIsCompatible(inputTrack, encoder))
{
return(outputPreviewTrack);
}
if (this.Profile.AudioEncoderFallback == null)
{
encoder = Encoders.AudioEncoders.First(a => !a.IsPassthrough);
}
else
{
encoder = Encoders.GetAudioEncoder(this.Profile.AudioEncoderFallback);
}
mixdown = Encoders.GetDefaultMixdown(encoder, 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 = Encoders.SanitizeMixdown(mixdown, encoder, inputTrack.ChannelLayout);
int previewSampleRate = sampleRate;
if (previewSampleRate == 0)
{
previewSampleRate = inputTrack.SampleRate;
}
int previewBitrate = bitrate;
if (previewBitrate == 0)
{
previewBitrate = Encoders.GetDefaultBitrate(encoder, previewSampleRate, previewMixdown);
}
else
{
previewBitrate = Encoders.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);
}