public void InitializeDropdowns()
{
audioCodec.Items.Clear();
audioCodec.Items.AddRange(mainForm.PackageSystem.AudioSettingsProviders.ValuesArray);
try { audioCodec.SelectedItem = mainForm.PackageSystem.AudioSettingsProviders["NAAC"]; }
catch (Exception)
{
try { audioCodec.SelectedIndex = 0; }
catch (Exception) { MessageBox.Show("No valid audio codecs are set up", "No valid audio codecs", MessageBoxButtons.OK, MessageBoxIcon.Error); }
}
fileTypeHandler = new FileTypeHandler <AudioType>(audioContainer, audioCodec, new FileTypeHandler <AudioType> .SupportedOutputGetter(delegate
{
return(audioEncoderProvider.GetSupportedOutput(codecHandler.CurrentSettingsProvider.EncoderType));
}));
codecHandler = new MultipleConfigurersHandler <AudioCodecSettings, string[], AudioCodec, AudioEncoderType>(audioCodec);
profileHandler = new ProfilesControlHandler <AudioCodecSettings, string[]>("Audio", mainForm, profileControl1, codecHandler.EditSettings,
new InfoGetter <string[]>(delegate { return(new string[] { AudioInput, AudioOutput }); }), codecHandler.Getter, codecHandler.Setter);
profileHandler.ConfigureCompleted += new EventHandler(profileHandler_ConfigureCompleted);
codecHandler.Register(profileHandler);
fileTypeHandler.RefreshFiletypes();
}
private void fixFileNameExtensions(VideoStream video, AudioJob[] audioStreams, ContainerType container)
{
AudioEncoderType[] audioCodecs = new AudioEncoderType[audioStreams.Length];
for (int i = 0; i < audioStreams.Length; i++)
{
audioCodecs[i] = audioStreams[i].Settings.EncoderType;
}
MuxPath path;
if (video.Settings == null)
{
path = mainForm.MuxProvider.GetMuxPath(VideoEncoderType.X264, audioCodecs, container);
}
else
{
path = mainForm.MuxProvider.GetMuxPath(video.Settings.EncoderType, audioCodecs, container);
}
if (path == null)
{
return;
}
List <AudioType> audioTypes = new List <AudioType>();
foreach (MuxableType type in path.InitialInputTypes)
{
if (type.outputType is VideoType)
{
// see http://forum.doom9.org/showthread.php?p=1243370#post1243370
if ((mainForm.Settings.ForceRawAVCExtension) && (video.Settings.EncoderType == VideoEncoderType.X264))
{
video.Output = Path.ChangeExtension(video.Output, ".264");
}
else
{
video.Output = Path.ChangeExtension(video.Output, type.outputType.Extension);
}
video.VideoType = type;
}
if (type.outputType is AudioType)
{
audioTypes.Add((AudioType)type.outputType);
}
}
AudioEncoderProvider aProvider = new AudioEncoderProvider();
for (int i = 0; i < audioStreams.Length; i++)
{
AudioType[] types = aProvider.GetSupportedOutput(audioStreams[i].Settings.EncoderType);
foreach (AudioType type in types)
{
if (audioTypes.Contains(type))
{
audioStreams[i].Output = Path.ChangeExtension(audioStreams[i].Output,
type.Extension);
break;
}
}
}
}
/// <summary>
/// Finds the best mux path if some of the inputs have not yet been
/// produced (they are yet to be encoded). When this is the case,
/// there is more flexibility, as some encoders can produce outputs
/// in multiple formats. This function suggests the output formats
/// they should produce as well as the mux path.
/// </summary>
/// <param name="undecidedInputs">List of encoder types for the inputs which have not yet been encoded</param>
/// <param name="decidedInputs">List of file types for the inputs which are already encoded</param>
/// <param name="containerType">Target container type</param>
/// <returns></returns>
private MuxPath findBestMuxPathAndConfig(List <IEncoderType> undecidedInputs, List <MuxableType> decidedInputs, ContainerType containerType)
{
if (undecidedInputs.Count == 0)
{
return(getShortestMuxPath(new MuxPath(decidedInputs, containerType), decidedInputs, containerType));
}
else
{
List <MuxPath> allPaths = new List <MuxPath>();
IEncoderType undecidedInput = undecidedInputs[0];
undecidedInputs.RemoveAt(0);
if (undecidedInput is VideoEncoderType)
{
VideoType[] allTypes = vProvider.GetSupportedOutput((VideoEncoderType)undecidedInput);
foreach (VideoType v in allTypes)
{
MuxableType input = new MuxableType(v, undecidedInput.Codec);
decidedInputs.Add(input);
MuxPath path = findBestMuxPathAndConfig(undecidedInputs, decidedInputs, containerType);
if (path != null)
{
allPaths.Add(path);
}
decidedInputs.Remove(input);
}
}
if (undecidedInput is AudioEncoderType)
{
AudioType[] allTypes = aProvider.GetSupportedOutput((AudioEncoderType)undecidedInput);
foreach (AudioType a in allTypes)
{
MuxableType input = new MuxableType(a, undecidedInput.Codec);
decidedInputs.Add(input);
MuxPath path = findBestMuxPathAndConfig(undecidedInputs, decidedInputs, containerType);
if (path != null)
{
allPaths.Add(path);
}
decidedInputs.Remove(input);
}
}
undecidedInputs.Insert(0, undecidedInput);
return(comparer.GetBestMuxPath(allPaths));
}
}
private void fixFileNameExtensions(VideoStream video, AudioJob[] audioStreams, ContainerType container)
{
AudioEncoderType[] audioCodecs = new AudioEncoderType[audioStreams.Length];
for (int i = 0; i < audioStreams.Length; i++)
{
audioCodecs[i] = audioStreams[i].Settings.EncoderType;
}
MuxPath path = mainForm.MuxProvider.GetMuxPath(video.Settings.EncoderType, audioCodecs, container);
if (path == null)
{
return;
}
List <AudioType> audioTypes = new List <AudioType>();
foreach (MuxableType type in path.InitialInputTypes)
{
if (type.outputType is VideoType)
{
video.Output = Path.ChangeExtension(video.Output, type.outputType.Extension);
video.VideoType = type;
}
if (type.outputType is AudioType)
{
audioTypes.Add((AudioType)type.outputType);
}
}
AudioEncoderProvider aProvider = new AudioEncoderProvider();
for (int i = 0; i < audioStreams.Length; i++)
{
AudioType[] types = aProvider.GetSupportedOutput(audioStreams[i].Settings.EncoderType);
foreach (AudioType type in types)
{
if (audioTypes.Contains(type))
{
audioStreams[i].Output = Path.ChangeExtension(audioStreams[i].Output,
type.Extension);
break;
}
}
}
}
private static void fixFileNameExtensions(VideoStream video, AudioJob[] audioStreams, ContainerType container)
{
AudioEncoderType[] audioCodecs = new AudioEncoderType[audioStreams.Length];
for (int i = 0; i < audioStreams.Length; i++)
{
audioCodecs[i] = audioStreams[i].Settings.EncoderType;
}
MuxPath path;
if (video.Settings == null)
{
path = MainForm.Instance.MuxProvider.GetMuxPath(VideoEncoderType.X264, audioCodecs, container);
}
else
{
path = MainForm.Instance.MuxProvider.GetMuxPath(video.Settings.EncoderType, audioCodecs, container);
}
if (path == null)
{
return;
}
List <AudioType> audioTypes = new List <AudioType>();
foreach (MuxableType type in path.InitialInputTypes)
{
if (type.outputType is VideoType)
{
if (video.Settings.EncoderType == VideoEncoderType.XVID && (type.outputType.ContainerType == ContainerType.AVI || type.outputType.ContainerType == ContainerType.MKV))
{
video.Output = Path.ChangeExtension(video.Output, ".m4v");
}
else if (video.Settings.EncoderType == VideoEncoderType.X264 && type.outputType.ContainerType == ContainerType.MP4)
{
video.Output = Path.ChangeExtension(video.Output, ".264");
}
else if (video.Settings.EncoderType == VideoEncoderType.X265 && (type.outputType.ContainerType == ContainerType.MKV || type.outputType.ContainerType == ContainerType.MP4))
{
video.Output = Path.ChangeExtension(video.Output, ".hevc");
}
else
{
video.Output = Path.ChangeExtension(video.Output, type.outputType.Extension);
}
video.VideoType = type;
}
if (type.outputType is AudioType)
{
audioTypes.Add((AudioType)type.outputType);
}
}
AudioEncoderProvider aProvider = new AudioEncoderProvider();
for (int i = 0; i < audioStreams.Length; i++)
{
AudioType[] types = aProvider.GetSupportedOutput(audioStreams[i].Settings.EncoderType);
foreach (AudioType type in types)
{
if (audioTypes.Contains(type))
{
string newFileName = Path.ChangeExtension(audioStreams[i].Output, type.Extension);
if (!audioStreams[i].Input.Equals(newFileName))
{
audioStreams[i].Output = newFileName;
}
break;
}
}
}
}
