Example #1
0
        /// <summary>
        /// Takes in a query which can be in any order and parses it.
        /// All varibles are then set so they can be used elsewhere.
        /// </summary>
        /// <param name="input">A ClI Query</param>
        /// <returns>A Parsed Query</returns>
        public static EncodeTask Parse(string input)
        {
            var parsed = new EncodeTask();

            #region Regular Expressions

            // Source
            Match title    = Regex.Match(input, @"-t ([0-9]*)");
            Match chapters = Regex.Match(input, @"-c ([0-9-]*)");

            // Output Settings
            Match format    = Regex.Match(input, @"-f ([a-zA-Z0-9]*)");
            Match grayscale = Regex.Match(input, @" -g");
            Match largerMp4 = Regex.Match(input, @" -4");
            Match ipodAtom  = Regex.Match(input, @" -I");

            // Picture Settings Tab
            Match width     = Regex.Match(input, @"-w ([0-9]*)");
            Match height    = Regex.Match(input, @"-l ([0-9]*)");
            Match maxWidth  = Regex.Match(input, @"-X ([0-9]*)");
            Match maxHeight = Regex.Match(input, @"-Y ([0-9]*)");
            Match crop      = Regex.Match(input, @"--crop ([0-9]*):([0-9]*):([0-9]*):([0-9]*)");

            Match looseAnamorphic  = Regex.Match(input, @"--loose-anamorphic");
            Match strictAnamorphic = Regex.Match(input, @"--strict-anamorphic");
            Match customAnamorphic = Regex.Match(input, @"--custom-anamorphic");

            Match keepDisplayAsect = Regex.Match(input, @"--keep-display-aspect");
            Match displayWidth     = Regex.Match(input, @"--display-width ([0-9]*)");
            Match pixelAspect      = Regex.Match(input, @"--pixel-aspect ([0-9]*):([0-9]*)");
            Match modulus          = Regex.Match(input, @"--modulus ([0-9]*)");

            // Picture Settings - Filters
            Match decomb          = Regex.Match(input, @" --decomb");
            Match decombValue     = Regex.Match(input, @" --decomb=\""([a-zA-Z0-9.:]*)\""");
            Match deinterlace     = Regex.Match(input, @"--deinterlace=\""([a-zA-Z0-9.:]*)\""");
            Match denoise         = Regex.Match(input, @"--denoise=\""([a-zA-Z0-9.:]*)\""");
            Match deblock         = Regex.Match(input, @"--deblock=([0-9:]*)");
            Match detelecine      = Regex.Match(input, @"--detelecine");
            Match detelecineValue = Regex.Match(input, @" --detelecine=\""([a-zA-Z0-9.:]*)\""");

            // Video Settings Tab
            Match videoEncoder   = Regex.Match(input, @"-e ([a-zA-Z0-9]*)");
            Match videoFramerate = Regex.Match(input, @"-r ([0-9.]*)");
            Match videoBitrate   = Regex.Match(input, @"-b ([0-9]*)");
            Match videoQuality   = Regex.Match(input, @"-q ([0-9.]*)");
            Match twoPass        = Regex.Match(input, @" -2");
            Match turboFirstPass = Regex.Match(input, @" -T");
            Match optimizeMP4    = Regex.Match(input, @" -O");
            Match pfr            = Regex.Match(input, @" --pfr");
            Match vfr            = Regex.Match(input, @" --vfr");
            Match cfr            = Regex.Match(input, @" --cfr");

            // Audio Settings Tab
            Match noAudio          = Regex.Match(input, @"-a none");
            Match audioTracks      = Regex.Match(input, @"-a ([0-9,]*)");
            Match audioTrackMixes  = Regex.Match(input, @"-6 ([0-9a-zA-Z,]*)");
            Match audioEncoders    = Regex.Match(input, @"-E ([a-zA-Z0-9+,:]*)");
            Match audioBitrates    = Regex.Match(input, @"-B ([0-9a-zA-Z,]*)");  // Auto = a-z
            Match audioSampleRates = Regex.Match(input, @"-R ([0-9a-zA-Z.,]*)"); // Auto = a-z
            Match drcValues        = Regex.Match(input, @"-D ([0-9.,]*)");
            Match gainValues       = Regex.Match(input, @"--gain=([0-9.,-]*)");

            // Chapters Tab
            Match chapterMarkers         = Regex.Match(input, @" -m");
            Match chapterMarkersFileMode = Regex.Match(input, @"--markers");

            // Advanced Tab
            Match advanced = Regex.Match(input, @"-x ([.,/a-zA-Z0-9=:-]*)");

            #endregion

            #region Set Varibles

            try
            {
                #region Source Tab

                if (title.Success)
                {
                    parsed.Title = int.Parse(title.ToString().Replace("-t ", string.Empty));
                }

                if (chapters.Success)
                {
                    parsed.PointToPointMode = PointToPointMode.Chapters;
                    string[] actTitles = chapters.ToString().Replace("-c ", string.Empty).Split('-');
                    parsed.StartPoint = int.Parse(actTitles[0]);
                    if (actTitles.Length > 1)
                    {
                        parsed.EndPoint = int.Parse(actTitles[1]);
                    }

                    if ((parsed.StartPoint == 1) && (parsed.EndPoint == 0))
                    {
                        parsed.EndPoint = parsed.StartPoint;
                    }
                }

                #endregion

                #region Output Settings

                if (format.Success)
                {
                    parsed.OutputFormat = Converters.GetFileFormat(format.Groups[1].ToString());
                }
                parsed.LargeFile     = largerMp4.Success;
                parsed.IPod5GSupport = ipodAtom.Success;
                parsed.OptimizeMP4   = optimizeMP4.Success;

                #endregion

                #region Picture Tab

                if (width.Success)
                {
                    parsed.Width = int.Parse(width.Groups[0].Value.Replace("-w ", string.Empty));
                }

                if (height.Success)
                {
                    parsed.Height = int.Parse(height.Groups[0].Value.Replace("-l ", string.Empty));
                }

                if (maxWidth.Success)
                {
                    parsed.MaxWidth = int.Parse(maxWidth.Groups[0].Value.Replace("-X ", string.Empty));
                }

                if (maxHeight.Success)
                {
                    parsed.MaxHeight = int.Parse(maxHeight.Groups[0].Value.Replace("-Y ", string.Empty));
                }

                if (crop.Success)
                {
                    try
                    {
                        string   values        = crop.ToString().Replace("--crop ", string.Empty);
                        string[] actCropValues = values.Split(':');
                        parsed.Cropping = new Cropping(
                            int.Parse(actCropValues[0]),
                            int.Parse(actCropValues[1]),
                            int.Parse(actCropValues[2]),
                            int.Parse(actCropValues[3]));
                    }
                    catch (Exception)
                    {
                        // No need to do anything.
                    }
                }

                if (strictAnamorphic.Success)
                {
                    parsed.Anamorphic = Anamorphic.Strict;
                }
                else if (looseAnamorphic.Success)
                {
                    parsed.Anamorphic = Anamorphic.Loose;
                }
                else if (customAnamorphic.Success)
                {
                    parsed.Anamorphic = Anamorphic.Custom;
                }
                else
                {
                    parsed.Anamorphic = Anamorphic.None;
                }

                parsed.KeepDisplayAspect = keepDisplayAsect.Success;

                if (displayWidth.Success)
                {
                    parsed.DisplayWidth =
                        double.Parse(displayWidth.Groups[0].Value.Replace("--display-width ", string.Empty), Culture);
                }

                if (pixelAspect.Success)
                {
                    parsed.PixelAspectX = int.Parse(pixelAspect.Groups[1].Value.Replace("--pixel-aspect ", string.Empty));
                }

                if (pixelAspect.Success && pixelAspect.Groups.Count >= 3)
                {
                    parsed.PixelAspectY = int.Parse(pixelAspect.Groups[2].Value.Replace("--pixel-aspect ", string.Empty));
                }

                if (modulus.Success)
                {
                    parsed.Modulus = int.Parse(modulus.Groups[0].Value.Replace("--modulus ", string.Empty));
                }

                #endregion

                #region Filters

                parsed.Decomb = Decomb.Off;
                if (decomb.Success)
                {
                    parsed.Decomb = Decomb.Default;
                    if (decombValue.Success)
                    {
                        parsed.CustomDecomb = decombValue.ToString().Replace("--decomb=", string.Empty).Replace("\"", string.Empty);
                    }
                }

                parsed.Deinterlace = Deinterlace.Off;
                if (deinterlace.Success)
                {
                    switch (deinterlace.ToString().Replace("--deinterlace=", string.Empty).Replace("\"", string.Empty).ToLower())
                    {
                    case "fast":
                        parsed.Deinterlace = Deinterlace.Fast;
                        break;

                    case "slow":
                        parsed.Deinterlace = Deinterlace.Slow;
                        break;

                    case "slower":
                        parsed.Deinterlace = Deinterlace.Slower;
                        break;

                    case "slowest":
                        parsed.Deinterlace = Deinterlace.Slowest;
                        break;

                    default:
                        parsed.Deinterlace       = Deinterlace.Custom;
                        parsed.CustomDeinterlace = deinterlace.ToString().Replace("--deinterlace=", string.Empty).Replace("\"", string.Empty).ToLower();
                        break;
                    }
                }

                parsed.Denoise = Denoise.Off;
                if (denoise.Success)
                {
                    switch (denoise.ToString().Replace("--denoise=", string.Empty).Replace("\"", string.Empty))
                    {
                    case "weak":
                        parsed.Denoise = Denoise.Weak;
                        break;

                    case "medium":
                        parsed.Denoise = Denoise.Medium;
                        break;

                    case "strong":
                        parsed.Denoise = Denoise.Strong;
                        break;

                    default:
                        parsed.Denoise       = Denoise.Custom;
                        parsed.CustomDenoise = denoise.ToString().Replace("--denoise=", string.Empty).Replace("\"", string.Empty);
                        break;
                    }
                }

                parsed.Deblock = 0;
                if (deblock.Success)
                {
                    int dval;
                    int.TryParse(deblock.ToString().Replace("--deblock=", string.Empty), out dval);
                    parsed.Deblock = dval;
                }

                parsed.Detelecine = Detelecine.Off;
                if (detelecine.Success)
                {
                    parsed.Detelecine = Detelecine.Default;
                    if (detelecineValue.Success)
                    {
                        parsed.CustomDetelecine = detelecineValue.ToString().Replace("--detelecine=", string.Empty).Replace("\"", string.Empty);
                        parsed.Detelecine       = Detelecine.Custom;
                    }
                }

                #endregion

                #region Video Settings Tab

                parsed.VideoEncoder = Converters.GetVideoEncoder(videoEncoder.ToString().Replace("-e ", string.Empty));

                if (videoFramerate.Success)
                {
                    double fps;
                    double.TryParse(videoFramerate.Groups[1].ToString(), out fps);
                    parsed.Framerate = fps;
                }

                if (pfr.Success)
                {
                    parsed.FramerateMode = FramerateMode.PFR;
                }
                else if (cfr.Success)
                {
                    parsed.FramerateMode = FramerateMode.CFR;
                }
                else
                {
                    parsed.FramerateMode = FramerateMode.VFR; // Default to VFR
                }
                parsed.Grayscale      = grayscale.Success;
                parsed.TwoPass        = twoPass.Success;
                parsed.TurboFirstPass = turboFirstPass.Success;

                if (videoBitrate.Success)
                {
                    parsed.VideoEncodeRateType = VideoEncodeRateMode.AverageBitrate;
                    parsed.VideoBitrate        = int.Parse(videoBitrate.ToString().Replace("-b ", string.Empty));
                }

                if (videoQuality.Success)
                {
                    float quality = float.Parse(videoQuality.ToString().Replace("-q ", string.Empty), Culture);
                    parsed.Quality = quality;
                }

                #endregion

                #region Audio Tab

                // Find out how many tracks we need to add by checking how many encoders or audio tracks are selected.
                int encoderCount = 0;
                if (audioEncoders.Success)
                {
                    string[] audioDataCounters = audioEncoders.ToString().Replace("-E ", string.Empty).Split(',');
                    encoderCount = audioDataCounters.Length;
                }

                // Get the data from the regular expression results
                string[] trackData        = null;
                string[] trackMixes       = null;
                string[] trackEncoders    = null;
                string[] trackBitrates    = null;
                string[] trackSamplerates = null;
                string[] trackDRCvalues   = null;
                string[] trackGainValues  = null;

                if (audioTracks.Success)
                {
                    trackData = audioTracks.ToString().Replace("-a ", string.Empty).Split(',');
                }
                if (audioTrackMixes.Success)
                {
                    trackMixes = audioTrackMixes.ToString().Replace("-6 ", string.Empty).Split(',');
                }
                if (audioEncoders.Success)
                {
                    trackEncoders = audioEncoders.ToString().Replace("-E ", string.Empty).Split(',');
                }
                if (audioBitrates.Success)
                {
                    trackBitrates = audioBitrates.ToString().Replace("-B ", string.Empty).Split(',');
                }
                if (audioSampleRates.Success)
                {
                    trackSamplerates = audioSampleRates.ToString().Replace("-R ", string.Empty).Split(',');
                }
                if (drcValues.Success)
                {
                    trackDRCvalues = drcValues.ToString().Replace("-D ", string.Empty).Split(',');
                }
                if (gainValues.Success)
                {
                    trackGainValues = gainValues.ToString().Replace("--gain=", string.Empty).Split(',');
                }

                // Create new Audio Track Classes and store them in the ArrayList
                List <AudioTrack> allAudioTrackInfo = new List <AudioTrack>();
                for (int x = 0; x < encoderCount; x++)
                {
                    AudioTrack track = new AudioTrack();
                    //if (trackData != null)
                    //    if (trackData.Length >= (x + 1)) // Audio Track
                    //        track.ScannedTrack = trackData[x].Trim();

                    if (trackMixes != null)
                    {
                        if (trackMixes.Length >= (x + 1)) // Audio Mix
                        {
                            track.MixDown = Converters.GetAudioMixDown(Converters.GetMixDown(trackMixes[x].Trim()));
                        }
                    }

                    if (trackEncoders != null)
                    {
                        if (trackEncoders.Length >= (x + 1)) // Audio Mix
                        {
                            track.Encoder = Converters.GetAudioEncoderFromCliString(trackEncoders[x].Trim());
                        }
                    }

                    if (trackBitrates != null)
                    {
                        if (trackBitrates.Length >= (x + 1)) // Audio Encoder
                        {
                            track.Bitrate = int.Parse(trackBitrates[x].Trim() == "auto" ? "0" : trackBitrates[x].Trim());
                        }
                    }

                    if (trackSamplerates != null)
                    {
                        if (trackSamplerates.Length >= (x + 1)) // Audio SampleRate
                        {
                            track.SampleRate = double.Parse(trackSamplerates[x].Replace("Auto", "0").Trim(), Culture);
                        }
                    }

                    if (trackDRCvalues != null)
                    {
                        if (trackDRCvalues.Length >= (x + 1)) // Audio DRC Values
                        {
                            track.DRC = double.Parse(trackDRCvalues[x].Trim(), Culture);
                        }
                    }

                    if (trackGainValues != null)
                    {
                        if (trackGainValues.Length >= (x + 1)) // Audio DRC Values
                        {
                            track.Gain = int.Parse(trackGainValues[x].Trim());
                        }
                    }

                    allAudioTrackInfo.Add(track);
                }

                parsed.AudioTracks = allAudioTrackInfo;

                #endregion

                #region Chapters Tab

                if (chapterMarkersFileMode.Success || chapterMarkers.Success)
                {
                    parsed.IncludeChapterMarkers = true;
                }

                #endregion

                #region Advanced and other

                if (advanced.Success)
                {
                    parsed.AdvancedEncoderOptions = advanced.ToString().Replace("-x ", string.Empty);
                }

                #endregion
            }
            catch (Exception exc)
            {
                throw new Exception("An error has occured in the QueryParser Utility.", exc);
            }

            #endregion

            return(parsed);
        }
        /// <summary>
        /// Get an EncodeJob model for a LibHB Encode.
        /// </summary>
        /// <param name="task">
        /// The task.
        /// </param>
        /// <returns>
        /// An Interop.EncodeJob model.
        /// </returns>
        public static EncodeJob GetEncodeJob(EncodeTask task)
        {
            // The current Job Configuration
            EncodeTask work = task;

            // Which will be converted to this EncodeJob Model.
            EncodeJob       job     = new EncodeJob();
            EncodingProfile profile = new EncodingProfile();

            job.EncodingProfile = profile;

            // Audio Settings
            profile.AudioEncodings = new List <AudioEncoding>();
            job.ChosenAudioTracks  = new List <int>();
            foreach (AudioTrack track in work.AudioTracks)
            {
                AudioEncoding newTrack = new AudioEncoding
                {
                    Bitrate       = track.Bitrate,
                    Drc           = track.DRC,
                    Gain          = track.Gain,
                    Encoder       = Converters.GetCliAudioEncoder(track.Encoder),
                    InputNumber   = track.Track.HasValue ? track.Track.Value : 0,
                    Mixdown       = Converters.GetCliMixDown(track.MixDown),
                    SampleRateRaw = GetSampleRateRaw(track.SampleRate),
                };

                profile.AudioEncodings.Add(newTrack);
                if (track.Track != null)
                {
                    job.ChosenAudioTracks.Add(track.Track.Value);
                }
            }

            // Title Settings
            job.OutputPath = work.Destination;
            job.SourcePath = work.Source;
            job.Title      = work.Title;
            // job.SourceType = work.Type;
            switch (work.PointToPointMode)
            {
            case PointToPointMode.Chapters:
                job.RangeType = VideoRangeType.Chapters;
                break;

            case PointToPointMode.Seconds:
                job.RangeType = VideoRangeType.Seconds;
                break;

            case PointToPointMode.Frames:
                job.RangeType = VideoRangeType.Frames;
                break;
            }

            if (work.PointToPointMode == PointToPointMode.Seconds)
            {
                job.SecondsEnd   = work.EndPoint;
                job.SecondsStart = work.StartPoint;
            }
            if (work.PointToPointMode == PointToPointMode.Chapters)
            {
                job.ChapterStart = work.StartPoint;
                job.ChapterEnd   = work.EndPoint;
            }
            if (work.PointToPointMode == PointToPointMode.Frames)
            {
                job.FramesEnd   = work.EndPoint;
                job.FramesStart = work.StartPoint;
            }

            job.Angle           = work.Angle;
            job.EncodingProfile = profile;

            // Output Settings
            profile.IPod5GSupport = work.IPod5GSupport;
            profile.Optimize      = work.OptimizeMP4;
            switch (work.OutputFormat)
            {
            case OutputFormat.Mp4:
            case OutputFormat.M4V:
                profile.ContainerName = "av_mp4";     // TODO make part of enum.
                break;

            case OutputFormat.Mkv:
                profile.ContainerName = "av_mkv";     // TODO make part of enum.
                break;
            }

            // Picture Settings
            profile.Anamorphic = work.Anamorphic;
            profile.Cropping   = new Cropping
            {
                Top    = work.Cropping.Top,
                Bottom = work.Cropping.Bottom,
                Left   = work.Cropping.Left,
                Right  = work.Cropping.Right
            };
            profile.CroppingType = CroppingType.Custom; // TODO deal with this better
            profile.DisplayWidth = work.DisplayWidth.HasValue
                           ? int.Parse(Math.Round(work.DisplayWidth.Value, 0).ToString())
                           : 0;
            profile.PixelAspectX      = work.PixelAspectX;
            profile.PixelAspectY      = work.PixelAspectY;
            profile.Height            = work.Height.HasValue ? work.Height.Value : 0;
            profile.KeepDisplayAspect = work.KeepDisplayAspect;
            profile.MaxHeight         = work.MaxHeight.HasValue ? work.MaxHeight.Value : 0;
            profile.MaxWidth          = work.MaxWidth.HasValue ? work.MaxWidth.Value : 0;
            profile.Modulus           = work.Modulus.HasValue ? work.Modulus.Value : 16;
            profile.UseDisplayWidth   = true;
            profile.Width             = work.Width.HasValue ? work.Width.Value : 0;

            // Filter Settings
            profile.CustomDecomb      = work.CustomDecomb;
            profile.CustomDeinterlace = work.CustomDeinterlace;
            profile.CustomDenoise     = work.CustomDenoise;
            profile.CustomDetelecine  = work.CustomDetelecine;
            if (work.Deblock > 4)
            {
                profile.Deblock = work.Deblock;
            }
            profile.Decomb      = work.Decomb;
            profile.Deinterlace = work.Deinterlace;
            profile.Denoise     = work.Denoise;
            profile.Detelecine  = work.Detelecine;
            profile.Grayscale   = work.Grayscale;

            // Video Settings
            profile.Framerate           = work.Framerate.HasValue ? work.Framerate.Value : 0;
            profile.ConstantFramerate   = work.FramerateMode == FramerateMode.CFR;
            profile.Quality             = work.Quality.HasValue ? work.Quality.Value : 0;
            profile.VideoBitrate        = work.VideoBitrate.HasValue ? work.VideoBitrate.Value : 0;
            profile.VideoEncodeRateType = work.VideoEncodeRateType;
            profile.VideoEncoder        = Converters.GetVideoEncoder(work.VideoEncoder);

            if (work.VideoEncoder == VideoEncoder.X264)
            {
                profile.VideoPreset = work.X264Preset.ToString().ToLower().Replace(" ", string.Empty);
                profile.VideoTunes  = new List <string>();

                if (work.X264Tune != x264Tune.None)
                {
                    profile.VideoTunes.Add(work.X264Tune.ToString().ToLower().Replace(" ", string.Empty));
                }

                if (work.FastDecode)
                {
                    profile.VideoTunes.Add("fastdecode");
                }
            }
            else if (work.VideoEncoder == VideoEncoder.X265)
            {
                profile.VideoPreset  = work.X265Preset.ToString().ToLower().Replace(" ", string.Empty);
                profile.VideoProfile = work.H265Profile.ToString().ToLower().Replace(" ", string.Empty);
                profile.VideoTunes   = new List <string>();
            }

            profile.VideoLevel   = work.H264Level;
            profile.VideoProfile = work.H264Profile.ToString().ToLower().Replace(" ", string.Empty); // TODO change these away from strings.

            // Chapter Markers
            profile.IncludeChapterMarkers = work.IncludeChapterMarkers;
            job.CustomChapterNames        = work.ChapterNames.Select(item => item.ChapterName).ToList();
            job.UseDefaultChapterNames    = work.IncludeChapterMarkers;

            // Advanced Settings
            profile.VideoOptions = work.AdvancedEncoderOptions;

            // Subtitles
            job.Subtitles = new Subtitles {
                SourceSubtitles = new List <SourceSubtitle>(), SrtSubtitles = new List <SrtSubtitle>()
            };
            foreach (SubtitleTrack track in work.SubtitleTracks)
            {
                if (track.IsSrtSubtitle)
                {
                    job.Subtitles.SrtSubtitles.Add(
                        new SrtSubtitle
                    {
                        CharacterCode = track.SrtCharCode,
                        Default       = track.Default,
                        FileName      = track.SrtFileName,
                        LanguageCode  = track.SrtLang,
                        Offset        = track.SrtOffset
                    });
                }
                else
                {
                    if (track.SourceTrack != null)
                    {
                        job.Subtitles.SourceSubtitles.Add(
                            new SourceSubtitle
                        {
                            BurnedIn    = track.Burned,
                            Default     = track.Default,
                            Forced      = track.Forced,
                            TrackNumber = track.SourceTrack.TrackNumber
                        });
                    }
                }
            }

            return(job);
        }
Example #3
0
        /// <summary>
        /// Takes in a query which can be in any order and parses it.
        /// All varibles are then set so they can be used elsewhere.
        /// </summary>
        /// <param name="input">A ClI Query</param>
        /// <returns>A Parsed Query</returns>
        public static EncodeTask Parse(string input)
        {
            var parsed = new EncodeTask();

            #region Regular Expressions

            // Source
            Match title    = Regex.Match(input, @"-t ([0-9]+)");
            Match chapters = Regex.Match(input, @"-c ([0-9-]+)");

            // Output Settings
            Match format    = Regex.Match(input, @"-f ([a-zA-Z0-9]+)");
            Match grayscale = Regex.Match(input, @" -g");
            Match ipodAtom  = Regex.Match(input, @" -I");

            // Picture Settings Tab
            Match width     = Regex.Match(input, @"-w ([0-9]+)");
            Match height    = Regex.Match(input, @"-l ([0-9]+)");
            Match maxWidth  = Regex.Match(input, @"-X ([0-9]+)");
            Match maxHeight = Regex.Match(input, @"-Y ([0-9]+)");
            Match crop      = Regex.Match(input, @"--crop ([0-9]*):([0-9]*):([0-9]*):([0-9]*)");

            Match looseAnamorphic  = Regex.Match(input, @"--loose-anamorphic");
            Match strictAnamorphic = Regex.Match(input, @"--strict-anamorphic");
            Match customAnamorphic = Regex.Match(input, @"--custom-anamorphic");

            Match keepDisplayAsect = Regex.Match(input, @"--keep-display-aspect");
            Match displayWidth     = Regex.Match(input, @"--display-width ([0-9]*)");
            Match pixelAspect      = Regex.Match(input, @"--pixel-aspect ([0-9]*):([0-9]*)");
            Match modulus          = Regex.Match(input, @"--modulus ([0-9]*)");

            // Picture Settings - Filters
            Match decomb          = Regex.Match(input, @" --decomb");
            Match decombValue     = Regex.Match(input, @" --decomb=([a-zA-Z0-9.:""\\]*)");
            Match deinterlace     = Regex.Match(input, @"--deinterlace=\""([a-zA-Z0-9.:]*)\""");
            Match denoise         = Regex.Match(input, @"--denoise=\""([a-zA-Z0-9.:]*)\""");
            Match nlmeans         = Regex.Match(input, @"--nlmeans=\""([a-zA-Z0-9.:]*)\""");
            Match nlmeansTune     = Regex.Match(input, @"--nlmeans-tune=\""([a-zA-Z0-9.:]*)\""");
            Match deblock         = Regex.Match(input, @"--deblock=([0-9:]*)");
            Match detelecine      = Regex.Match(input, @"--detelecine");
            Match detelecineValue = Regex.Match(input, @" --detelecine=\""([a-zA-Z0-9.:]*)\""");

            // Video Settings Tab
            Match videoEncoder   = Regex.Match(input, @"-e ([a-zA-Z0-9]+)");
            Match videoFramerate = Regex.Match(input, @"-r ([0-9.]+)");
            Match videoBitrate   = Regex.Match(input, @"-b ([0-9]+)");
            Match videoQuality   = Regex.Match(input, @"-q ([0-9.]+)");
            Match twoPass        = Regex.Match(input, @" -2");
            Match turboFirstPass = Regex.Match(input, @" -T");
            Match optimizeMP4    = Regex.Match(input, @" -O");
            Match pfr            = Regex.Match(input, @" --pfr");
            Match cfr            = Regex.Match(input, @" --cfr");

            // Audio Settings Tab
            Match audioTrackMixes  = Regex.Match(input, @"-6 ([0-9a-zA-Z,]+)");
            Match audioEncoders    = Regex.Match(input, @"-E ([a-zA-Z0-9+,:\*]+)");
            Match audioBitrates    = Regex.Match(input, @"-B ([0-9a-zA-Z,]+)");  // Auto = a-z
            Match audioSampleRates = Regex.Match(input, @"-R ([0-9a-zA-Z.,]+)"); // Auto = a-z
            Match drcValues        = Regex.Match(input, @"-D ([0-9.,]+)");
            Match gainValues       = Regex.Match(input, @"--gain=([0-9.,-]+)");
            Match fallbackEncoder  = Regex.Match(input, @"--audio-fallback([a-zA-Z0-9:=\s ]*)");
            Match allowedPassthru  = Regex.Match(input, @"--audio-copy-mask([a-zA-Z0-9:,=\s ]*)");

            // Chapters Tab
            Match chapterMarkers         = Regex.Match(input, @" -m");
            Match chapterMarkersFileMode = Regex.Match(input, @"--markers");

            // Advanced Tab
            Match advanced    = Regex.Match(input, @"-x ([.,/a-zA-Z0-9=:-]*)");
            Match x264Preset  = Regex.Match(input, @"--x264-preset([=a-zA-Z0-9\s ]*)");
            Match x264Tune    = Regex.Match(input, @"--x264-tune([=,a-zA-Z0-9\s ]*)");
            Match h264Profile = Regex.Match(input, @"--h264-profile([=a-zA-Z0-9\s ]*)");
            Match x264Profile = Regex.Match(input, @"--x264-profile([=a-zA-Z0-9\s ]*)");
            Match h264Level   = Regex.Match(input, @"--h264-level([=a-zA-Z0-9.\s ]*)");

            Match x265Profile = Regex.Match(input, @"--x265-profile([=a-zA-Z0-9\s ]*)");
            Match x265Tune    = Regex.Match(input, @"--x265-tune([=,a-zA-Z0-9\s ]*)");
            Match x265Preset  = Regex.Match(input, @"--x265-preset([=a-zA-Z0-9\s ]*)");
            #endregion

            #region Set Varibles

            try
            {
                #region Source Tab

                if (title.Success)
                {
                    parsed.Title = int.Parse(title.ToString().Replace("-t ", string.Empty));
                }

                if (chapters.Success)
                {
                    parsed.PointToPointMode = PointToPointMode.Chapters;
                    string[] actTitles = chapters.ToString().Replace("-c ", string.Empty).Split('-');
                    parsed.StartPoint = int.Parse(actTitles[0]);
                    if (actTitles.Length > 1)
                    {
                        parsed.EndPoint = int.Parse(actTitles[1]);
                    }

                    if ((parsed.StartPoint == 1) && (parsed.EndPoint == 0))
                    {
                        parsed.EndPoint = parsed.StartPoint;
                    }
                }

                #endregion

                #region Output Settings

                if (format.Success)
                {
                    parsed.OutputFormat = Converters.GetFileFormat(format.Groups[1].ToString());
                }
                parsed.IPod5GSupport = ipodAtom.Success;
                parsed.OptimizeMP4   = optimizeMP4.Success;

                #endregion

                #region Picture Tab

                if (width.Success)
                {
                    parsed.Width = int.Parse(width.Groups[0].Value.Replace("-w ", string.Empty));
                }

                if (height.Success)
                {
                    parsed.Height = int.Parse(height.Groups[0].Value.Replace("-l ", string.Empty));
                }

                if (maxWidth.Success)
                {
                    parsed.MaxWidth = int.Parse(maxWidth.Groups[0].Value.Replace("-X ", string.Empty));
                }

                if (maxHeight.Success)
                {
                    parsed.MaxHeight = int.Parse(maxHeight.Groups[0].Value.Replace("-Y ", string.Empty));
                }

                if (crop.Success)
                {
                    try
                    {
                        string   values        = crop.ToString().Replace("--crop ", string.Empty);
                        string[] actCropValues = values.Split(':');
                        parsed.Cropping = new Cropping(
                            int.Parse(actCropValues[0]),
                            int.Parse(actCropValues[1]),
                            int.Parse(actCropValues[2]),
                            int.Parse(actCropValues[3]));
                        parsed.HasCropping = true;
                    }
                    catch (Exception)
                    {
                        parsed.Cropping    = null;
                        parsed.HasCropping = false;
                        // No need to do anything.
                    }
                }

                if (strictAnamorphic.Success)
                {
                    parsed.Anamorphic = Anamorphic.Strict;
                }
                else if (looseAnamorphic.Success)
                {
                    parsed.Anamorphic = Anamorphic.Loose;
                }
                else if (customAnamorphic.Success)
                {
                    parsed.Anamorphic = Anamorphic.Custom;
                }
                else
                {
                    parsed.Anamorphic = Anamorphic.None;
                }

                parsed.KeepDisplayAspect = keepDisplayAsect.Success;

                if (displayWidth.Success)
                {
                    parsed.DisplayWidth =
                        double.Parse(displayWidth.Groups[0].Value.Replace("--display-width ", string.Empty), Culture);
                }

                if (pixelAspect.Success)
                {
                    parsed.PixelAspectX = int.Parse(pixelAspect.Groups[1].Value.Replace("--pixel-aspect ", string.Empty));
                }

                if (pixelAspect.Success && pixelAspect.Groups.Count >= 3)
                {
                    parsed.PixelAspectY = int.Parse(pixelAspect.Groups[2].Value.Replace("--pixel-aspect ", string.Empty));
                }

                if (modulus.Success)
                {
                    parsed.Modulus = int.Parse(modulus.Groups[0].Value.Replace("--modulus ", string.Empty));
                }

                #endregion

                #region Filters

                parsed.Decomb = Decomb.Off;
                if (decomb.Success)
                {
                    parsed.Decomb = Decomb.Default;
                    if (decombValue.Success)
                    {
                        string value = decombValue.ToString().Replace("--decomb=", string.Empty).Replace("\"", string.Empty).Trim();

                        if (value == "bob")
                        {
                            parsed.Decomb = Decomb.Bob;
                        }
                        else if (value == "fast")
                        {
                            parsed.Decomb = Decomb.Fast;
                        }
                        else
                        {
                            parsed.CustomDecomb = value;
                            parsed.Decomb       = parsed.CustomDecomb == "7:2:6:9:1:80" ? Decomb.Fast : Decomb.Custom;
                        }
                    }
                }

                parsed.Deinterlace = Deinterlace.Off;
                if (deinterlace.Success)
                {
                    switch (deinterlace.ToString().Replace("--deinterlace=", string.Empty).Replace("\"", string.Empty).ToLower())
                    {
                    case "fast":
                        parsed.Deinterlace = Deinterlace.Fast;
                        break;

                    case "slow":
                        parsed.Deinterlace = Deinterlace.Slow;
                        break;

                    case "slower":
                        parsed.Deinterlace = Deinterlace.Slower;
                        break;

                    case "bob":
                        parsed.Deinterlace = Deinterlace.Bob;
                        break;

                    default:
                        parsed.Deinterlace       = Deinterlace.Custom;
                        parsed.CustomDeinterlace = deinterlace.ToString().Replace("--deinterlace=", string.Empty).Replace("\"", string.Empty).ToLower();
                        break;
                    }
                }

                parsed.Denoise = Denoise.Off;
                if (denoise.Success)
                {
                    parsed.Denoise = Denoise.hqdn3d;
                    switch (denoise.ToString().Replace("--denoise=", string.Empty).Replace("\"", string.Empty))
                    {
                    case "weak":
                        parsed.DenoisePreset = DenoisePreset.Weak;
                        break;

                    case "medium":
                        parsed.DenoisePreset = DenoisePreset.Medium;
                        break;

                    case "strong":
                        parsed.DenoisePreset = DenoisePreset.Strong;
                        break;

                    default:
                        parsed.DenoisePreset = DenoisePreset.Custom;
                        parsed.CustomDenoise = denoise.ToString().Replace("--denoise=", string.Empty).Replace("\"", string.Empty);
                        break;
                    }
                }

                if (nlmeans.Success)
                {
                    parsed.Denoise = Denoise.NLMeans;
                    switch (nlmeans.ToString().Replace("--nlmeans=", string.Empty).Replace("\"", string.Empty))
                    {
                    case "ultralight":
                        parsed.DenoisePreset = DenoisePreset.Ultralight;
                        break;

                    case "light":
                        parsed.DenoisePreset = DenoisePreset.Light;
                        break;

                    case "medium":
                        parsed.DenoisePreset = DenoisePreset.Medium;
                        break;

                    case "strong":
                        parsed.DenoisePreset = DenoisePreset.Strong;
                        break;
                    }

                    if (nlmeansTune.Success)
                    {
                        switch (nlmeansTune.ToString().Replace("--nlmeans-tune=", string.Empty).Replace("\"", string.Empty))
                        {
                        case "animation":
                            parsed.DenoiseTune = DenoiseTune.Animation;
                            break;

                        case "film":
                            parsed.DenoiseTune = DenoiseTune.Film;
                            break;

                        case "grain":
                            parsed.DenoiseTune = DenoiseTune.Grain;
                            break;

                        case "highmotion":
                            parsed.DenoiseTune = DenoiseTune.HighMotion;
                            break;
                        }
                    }
                }

                parsed.Deblock = 0;
                if (deblock.Success)
                {
                    int dval;
                    int.TryParse(deblock.ToString().Replace("--deblock=", string.Empty), out dval);
                    parsed.Deblock = dval;
                }

                parsed.Detelecine = Detelecine.Off;
                if (detelecine.Success)
                {
                    parsed.Detelecine = Detelecine.Default;
                    if (detelecineValue.Success)
                    {
                        parsed.CustomDetelecine = detelecineValue.ToString().Replace("--detelecine=", string.Empty).Replace("\"", string.Empty);
                        parsed.Detelecine       = Detelecine.Custom;
                    }
                }

                #endregion

                #region Video Settings Tab

                parsed.VideoEncoder = videoEncoder.Success
                                          ? Converters.GetVideoEncoder(videoEncoder.ToString().Replace("-e ", string.Empty))
                                          : VideoEncoder.FFMpeg;

                if (videoFramerate.Success)
                {
                    double fps;
                    double.TryParse(videoFramerate.Groups[1].ToString(), NumberStyles.Any, CultureInfo.InvariantCulture, out fps);
                    parsed.Framerate = fps;
                }

                if (pfr.Success)
                {
                    parsed.FramerateMode = FramerateMode.PFR;
                }
                else if (cfr.Success)
                {
                    parsed.FramerateMode = FramerateMode.CFR;
                }
                else
                {
                    parsed.FramerateMode = FramerateMode.VFR; // Default to VFR
                }
                parsed.Grayscale      = grayscale.Success;
                parsed.TwoPass        = twoPass.Success;
                parsed.TurboFirstPass = turboFirstPass.Success;

                if (videoBitrate.Success)
                {
                    parsed.VideoEncodeRateType = VideoEncodeRateType.AverageBitrate;
                    parsed.VideoBitrate        = int.Parse(videoBitrate.ToString().Replace("-b ", string.Empty));
                }

                if (videoQuality.Success)
                {
                    float quality = float.Parse(videoQuality.ToString().Replace("-q ", string.Empty), Culture);
                    parsed.Quality = quality;

                    parsed.VideoEncodeRateType = VideoEncodeRateType.ConstantQuality;
                }

                #endregion

                #region Audio Tab

                // Find out how many tracks we need to add by checking how many encoders or audio tracks are selected.
                int encoderCount = 0;
                if (audioEncoders.Success)
                {
                    string[] audioDataCounters = audioEncoders.ToString().Replace("-E ", string.Empty).Split(',');
                    encoderCount = audioDataCounters.Length;
                }

                // Get the data from the regular expression results
                string[] trackMixes       = null;
                string[] trackEncoders    = null;
                string[] trackBitrates    = null;
                string[] trackSamplerates = null;
                string[] trackDRCvalues   = null;
                string[] trackGainValues  = null;

                if (audioTrackMixes.Success)
                {
                    trackMixes = audioTrackMixes.ToString().Replace("-6 ", string.Empty).Split(',');
                }
                if (audioEncoders.Success)
                {
                    trackEncoders = audioEncoders.ToString().Replace("-E ", string.Empty).Split(',');
                }
                if (audioBitrates.Success)
                {
                    trackBitrates = audioBitrates.ToString().Replace("-B ", string.Empty).Split(',');
                }
                if (audioSampleRates.Success)
                {
                    trackSamplerates = audioSampleRates.ToString().Replace("-R ", string.Empty).Split(',');
                }
                if (drcValues.Success)
                {
                    trackDRCvalues = drcValues.ToString().Replace("-D ", string.Empty).Split(',');
                }
                if (gainValues.Success)
                {
                    trackGainValues = gainValues.ToString().Replace("--gain=", string.Empty).Split(',');
                }

                // Create new Audio Track Classes and store them in the ArrayList
                ObservableCollection <AudioTrack> allAudioTrackInfo = new ObservableCollection <AudioTrack>();
                for (int x = 0; x < encoderCount; x++)
                {
                    AudioTrack track = new AudioTrack();

                    if (trackMixes != null)
                    {
                        if (trackMixes.Length >= (x + 1)) // Audio Mix
                        {
                            track.MixDown = Converters.GetAudioMixDown(Converters.GetMixDown(trackMixes[x].Trim()));
                        }
                    }

                    if (trackEncoders != null)
                    {
                        if (trackEncoders.Length >= (x + 1)) // Audio Mix
                        {
                            track.Encoder = Converters.GetAudioEncoderFromCliString(trackEncoders[x].Trim());
                        }
                    }

                    if (trackBitrates != null)
                    {
                        if (trackBitrates.Length >= (x + 1)) // Audio Encoder
                        {
                            track.Bitrate = int.Parse(trackBitrates[x].Trim() == "auto" ? "0" : trackBitrates[x].Trim());
                        }
                    }

                    if (trackSamplerates != null)
                    {
                        if (trackSamplerates.Length >= (x + 1)) // Audio SampleRate
                        {
                            track.SampleRate = double.Parse(trackSamplerates[x].Replace("Auto", "0").Trim(), Culture);
                        }
                    }

                    if (trackDRCvalues != null)
                    {
                        if (trackDRCvalues.Length >= (x + 1)) // Audio DRC Values
                        {
                            track.DRC = double.Parse(trackDRCvalues[x].Trim(), Culture);
                        }
                    }

                    if (trackGainValues != null)
                    {
                        if (trackGainValues.Length >= (x + 1)) // Audio DRC Values
                        {
                            track.Gain = int.Parse(trackGainValues[x].Trim());
                        }
                    }

                    allAudioTrackInfo.Add(track);
                }

                parsed.AudioTracks = allAudioTrackInfo;

                if (fallbackEncoder.Success)
                {
                    parsed.AllowedPassthruOptions.AudioEncoderFallback =
                        Converters.GetAudioEncoderFromCliString(fallbackEncoder.Groups[1].ToString().Trim());
                }

                if (allowedPassthru.Success)
                {
                    string[] allowedEncoders = allowedPassthru.Groups[1].ToString().Trim().Split(',');

                    parsed.AllowedPassthruOptions.AudioAllowAACPass   = allowedEncoders.Contains("aac");
                    parsed.AllowedPassthruOptions.AudioAllowAC3Pass   = allowedEncoders.Contains("ac3");
                    parsed.AllowedPassthruOptions.AudioAllowDTSHDPass = allowedEncoders.Contains("dtshd");
                    parsed.AllowedPassthruOptions.AudioAllowDTSPass   = allowedEncoders.Contains("dts");
                    parsed.AllowedPassthruOptions.AudioAllowMP3Pass   = allowedEncoders.Contains("mp3");
                }

                #endregion

                #region Chapters Tab

                if (chapterMarkersFileMode.Success || chapterMarkers.Success)
                {
                    parsed.IncludeChapterMarkers = true;
                }

                #endregion

                #region Advanced and other

                if (advanced.Success)
                {
                    parsed.AdvancedEncoderOptions = advanced.ToString().Replace("-x ", string.Empty);
                }

                if (x264Preset.Success)
                {
                    parsed.X264Preset =
                        Converters.Getx264PresetFromCli(x264Preset.ToString().Replace("--x264-preset", string.Empty).Replace("=", string.Empty).Trim());
                }

                if (h264Profile.Success)
                {
                    parsed.H264Profile =
                        Converters.Getx264ProfileFromCli(h264Profile.ToString().Replace("--h264-profile", string.Empty).Replace("=", string.Empty).Trim());
                }

                if (x264Profile.Success)
                {
                    parsed.H264Profile =
                        Converters.Getx264ProfileFromCli(x264Profile.ToString().Replace("--x264-profile", string.Empty).Replace("=", string.Empty).Trim());
                }

                if (h264Level.Success)
                {
                    parsed.H264Level =
                        h264Level.ToString().Replace("--h264-level", string.Empty).Replace("=", string.Empty).Trim();
                }

                if (x264Tune.Success)
                {
                    string tuneOptions =
                        x264Tune.ToString().Replace("--x264-tune", string.Empty).Replace("=", string.Empty).Trim();

                    parsed.FastDecode = tuneOptions.Contains("fastdecode");

                    // Remove these options. They are not in the dropdown.
                    tuneOptions = tuneOptions.Replace("fastdecode", string.Empty).Replace(
                        ",", string.Empty);

                    parsed.X264Tune = Converters.Getx264TuneFromCli(tuneOptions);
                }

                if (x265Preset.Success)
                {
                    parsed.X265Preset =
                        Converters.Getx265PresetFromCli(x265Preset.ToString().Replace("--x265-preset", string.Empty).Replace("=", string.Empty).Trim());
                }

                if (h264Profile.Success)
                {
                    parsed.H265Profile =
                        Converters.Getx265ProfileFromCli(h264Profile.ToString().Replace("--h265-profile", string.Empty).Replace("=", string.Empty).Trim());
                }

                if (x265Profile.Success)
                {
                    parsed.H265Profile =
                        Converters.Getx265ProfileFromCli(x265Profile.ToString().Replace("--x265-profile", string.Empty).Replace("=", string.Empty).Trim());
                }

                if (x265Tune.Success)
                {
                    string tuneOptions =
                        x265Tune.ToString().Replace("--x265-tune", string.Empty).Replace("=", string.Empty).Trim();

                    parsed.FastDecode = tuneOptions.Contains("fastdecode");

                    // Remove these options. They are not in the dropdown.
                    tuneOptions = tuneOptions.Replace("fastdecode", string.Empty).Replace(
                        ",", string.Empty);

                    parsed.X265Tune = Converters.Getx265TuneFromCli(tuneOptions);
                }

                #endregion
            }
            catch (Exception exc)
            {
                throw new Exception("An error has occured in the QueryParser Utility.", exc);
            }

            #endregion

            return(parsed);
        }
Example #4
0
        /**
         * TODO:
         * - Update with the new vfr,pfr,cfr keys
         * - Clean up this code, it's pretty nasty right now.
         **/

        #region Import

        public static EncodeTask Import(string filename)
        {
            XmlNode root = loadFile(filename);

            if (root == null)
            {
                return(null);
            }

            // We'll query a query parser object and use it's public var structures to store all the data.
            // This will allow the preset loader logic to be used instead of writing custom logic just for this file.
            EncodeTask parsed      = new EncodeTask();
            string     qualityMode = string.Empty;

            #region Get a List of Audio Track Objects
            XmlNode           audioListDict = root.ChildNodes[2].ChildNodes[0].FirstChild.ChildNodes[1];
            List <AudioTrack> audioTracks   = new List <AudioTrack>();

            for (int i = 0; i < audioListDict.ChildNodes.Count; i++)
            {
                XmlNode    audioChannel = audioListDict.ChildNodes[i];
                AudioTrack track        = new AudioTrack();

                for (int subi = 0; subi < audioChannel.ChildNodes.Count; subi += 2)
                {
                    // Audio Channel Information is here.
                    string key   = audioChannel.ChildNodes[subi].InnerText;
                    string value = audioChannel.ChildNodes[subi + 1].InnerText;
                    switch (key)
                    {
                    case "AudioBitrate":
                        track.Bitrate = int.Parse(value);
                        break;

                    case "AudioEncoder":
                        track.Encoder = Converters.GetAudioEncoder(value.Trim());
                        break;

                    case "AudioMixdown":
                        track.MixDown = Converters.GetAudioMixDown(value.Trim());
                        break;

                    case "AudioSamplerate":
                        track.SampleRate = double.Parse(value);
                        break;

                    case "AudioTrack":
                        track.Track = int.Parse(value);
                        break;

                    case "AudioTrackDRCSlider":
                        track.DRC = double.Parse(value);
                        break;
                    }
                }
                audioTracks.Add(track);
                parsed.AudioTracks = audioTracks;
            }
            #endregion

            #region Parse the reset of the plist keys into local variables

            XmlNode presetSettings = root.ChildNodes[2].ChildNodes[0].FirstChild;

            // Start from 2 to avoid the audio settings which we don't need.
            for (int i = 2; i < presetSettings.ChildNodes.Count; i += 2)
            {
                string key   = presetSettings.ChildNodes[i].InnerText;
                string value = presetSettings.ChildNodes[i + 1].InnerText;

                switch (key)
                {
                // Output Settings
                case "FileFormat":
                    parsed.OutputFormat = Converters.GetFileFormat(value);
                    break;

                case "Mp4HttpOptimize":
                    parsed.OptimizeMP4 = value == "1";
                    break;

                case "Mp4LargeFile":
                    parsed.IPod5GSupport = value == "1";
                    break;

                case "Mp4iPodCompatible":
                    parsed.IPod5GSupport = value == "1";
                    break;

                // Picture Settings
                case "PictureAutoCrop":
                    // Not used
                    break;

                case "PictureTopCrop":
                    parsed.Cropping.Top = int.Parse(value);
                    break;

                case "PictureBottomCrop":
                    parsed.Cropping.Bottom = int.Parse(value);
                    break;

                case "PictureLeftCrop":
                    parsed.Cropping.Left = int.Parse(value);
                    break;

                case "PictureRightCrop":
                    parsed.Cropping.Right = int.Parse(value);
                    break;

                case "PictureHeight":
                    parsed.Height = int.Parse(value);
                    break;

                case "PictureWidth":
                    parsed.Width = int.Parse(value);
                    break;

                case "PictureKeepRatio":
                    parsed.KeepDisplayAspect = value == "1";
                    break;

                case "PicturePAR":
                    switch (value)
                    {
                    case "0":
                        parsed.Anamorphic = Anamorphic.None;
                        break;

                    default:
                        parsed.Anamorphic = Anamorphic.Strict;
                        break;

                    case "2":
                        parsed.Anamorphic = Anamorphic.Loose;
                        break;

                    case "3":
                        parsed.Anamorphic = Anamorphic.Custom;
                        break;
                    }
                    break;

                // Filters
                case "PictureDeblock":
                    parsed.Deblock = int.Parse(value);
                    break;

                case "PictureDecomb":
                    parsed.Decomb = Decomb.Off;
                    // Don't place custom here as it's handled in the filter panel
                    if (value == "2")
                    {
                        parsed.Decomb = Decomb.Default;
                    }
                    break;

                case "PictureDecombCustom":
                    if (value != string.Empty)
                    {
                        parsed.CustomDecomb = value;
                    }
                    break;

                case "PictureDecombDeinterlace":
                    // Not Used
                    break;

                case "PictureDeinterlace":
                    switch (value)
                    {
                    case "0":
                        parsed.Deinterlace = Deinterlace.Off;
                        break;

                    // Don't place custom here as it's handled in the filter panel
                    case "2":
                        parsed.Deinterlace = Deinterlace.Fast;
                        break;

                    case "3":
                        parsed.Deinterlace = Deinterlace.Slow;
                        break;

                    case "4":
                        parsed.Deinterlace = Deinterlace.Slower;
                        break;
                    }
                    break;

                case "PictureDeinterlaceCustom":
                    if (value != string.Empty)
                    {
                        parsed.CustomDeinterlace = value;
                    }
                    break;

                case "PictureDenoise":
                    switch (value)
                    {
                    case "0":
                        parsed.Denoise = Denoise.Off;
                        break;

                    // Don't place custom here as it's handled in the filter panel
                    case "2":
                        parsed.Denoise = Denoise.Weak;
                        break;

                    case "3":
                        parsed.Denoise = Denoise.Medium;
                        break;

                    case "4":
                        parsed.Denoise = Denoise.Strong;
                        break;
                    }

                    break;

                case "PictureDenoiseCustom":
                    if (value != string.Empty)
                    {
                        parsed.CustomDenoise = value;
                    }
                    break;

                case "PictureDetelecine":
                    parsed.Detelecine = Detelecine.Off;
                    if (value == "1")
                    {
                        parsed.Detelecine = Detelecine.Default;
                    }
                    break;

                case "PictureDetelecineCustom":
                    if (value != string.Empty)
                    {
                        parsed.CustomDetelecine = value;
                    }
                    break;

                // Video Tab
                case "VideoAvgBitrate":
                    parsed.VideoBitrate = int.Parse(value);
                    break;

                case "VideoEncoder":
                    parsed.VideoEncoder = Converters.GetVideoEncoder(value);
                    break;

                case "VideoFramerate":
                    parsed.Framerate = int.Parse(value);
                    break;

                case "VideoGrayScale":
                    parsed.Grayscale = value == "1";
                    break;

                case "VideoQualitySlider":
                    parsed.Quality = double.Parse(value);
                    break;

                case "VideoQualityType":     // The Type of Quality Mode used
                    qualityMode = value;
                    break;

                case "VideoTurboTwoPass":
                    parsed.TurboFirstPass = value == "1";
                    break;

                case "VideoTwoPass":
                    parsed.TwoPass = value == "1";
                    break;

                // Chapter Markers Tab
                case "ChapterMarkers":
                    parsed.IncludeChapterMarkers = value == "1";
                    break;

                // Advanced x264 tab
                case "x264Option":
                    parsed.AdvancedEncoderOptions = value;
                    break;

                // Preset Information
                case "PresetBuildNumber":
                    parsed.PresetBuildNumber = int.Parse(value);
                    break;

                case "PresetDescription":
                    parsed.PresetDescription = value;
                    break;

                case "PresetName":
                    parsed.PresetName = value;
                    break;

                case "Type":
                    parsed.Type = value;
                    break;

                case "UsesMaxPictureSettings":
                    parsed.UsesMaxPictureSettings = value == "1";
                    break;

                case "UsesPictureFilters":
                    parsed.UsesPictureFilters = value == "1";
                    break;

                case "UsesPictureSettings":
                    parsed.UsesPictureSettings = value == "1";
                    break;
                }
            }

            // Kill any Quality values we don't need.
            switch (qualityMode)
            {
            case "1":     // Avg Bitrate
                parsed.VideoEncodeRateType = VideoEncodeRateMode.AverageBitrate;
                break;

            case "2":     // CQ
                parsed.VideoEncodeRateType = VideoEncodeRateMode.ConstantQuality;
                break;
            }
            #endregion

            return(parsed);
        }
Example #5
0
        /// <summary>
        /// Get an EncodeJob model for a LibHB Encode.
        /// </summary>
        /// <param name="task">
        /// The task.
        /// </param>
        /// <returns>
        /// An Interop.EncodeJob model.
        /// </returns>
        public static EncodeJob GetEncodeJob(QueueTask task)
        {
            // Sanity Checking
            if (task == null || task.Task == null)
            {
                return(null);
            }

            // The current Job Configuration
            EncodeTask work = task.Task;

            // Which will be converted to this EncodeJob Model.
            EncodeJob job = new EncodeJob();

            EncodingProfile profile = new EncodingProfile();

            job.EncodingProfile = profile;

            profile.Anamorphic = work.Anamorphic;

            profile.AudioEncodings = new List <AudioEncoding>();
            job.ChosenAudioTracks  = new List <int>();
            foreach (AudioTrack track in work.AudioTracks)
            {
                AudioEncoding newTrack = new AudioEncoding
                {
                    Bitrate       = track.Bitrate,
                    Drc           = track.DRC,
                    Gain          = track.Gain,
                    Encoder       = Converters.GetCliAudioEncoder(track.Encoder),
                    InputNumber   = track.Track.HasValue ? track.Track.Value : 0,
                    Mixdown       = Converters.GetCliMixDown(track.MixDown),
                    SampleRateRaw = GetSampleRateRaw(track.SampleRate),
                };

                profile.AudioEncodings.Add(newTrack);
                if (track.Track != null)
                {
                    job.ChosenAudioTracks.Add(track.Track.Value);
                }
            }
            profile.Cropping = new Cropping
            {
                Top    = work.Cropping.Top,
                Bottom = work.Cropping.Bottom,
                Left   = work.Cropping.Left,
                Right  = work.Cropping.Right
            };

            profile.CroppingType      = CroppingType.Custom; // TODO deal with this better
            profile.CustomDecomb      = work.CustomDecomb;
            profile.CustomDeinterlace = work.CustomDeinterlace;
            profile.CustomDenoise     = work.CustomDenoise;
            profile.CustomDetelecine  = work.CustomDetelecine;
            profile.Deblock           = work.Deblock;
            profile.Decomb            = work.Decomb;
            profile.Deinterlace       = work.Deinterlace;
            profile.Denoise           = work.Denoise;
            profile.Detelecine        = work.Detelecine;
            profile.DisplayWidth      = work.DisplayWidth.HasValue
                                       ? int.Parse(Math.Round(work.DisplayWidth.Value, 0).ToString())
                                       : 0;
            profile.Framerate             = work.Framerate.HasValue ? work.Framerate.Value : 0;
            profile.Grayscale             = work.Grayscale;
            profile.Height                = work.Height.HasValue ? work.Height.Value : 0;
            profile.IPod5GSupport         = work.IPod5GSupport;
            profile.IncludeChapterMarkers = work.IncludeChapterMarkers;
            profile.KeepDisplayAspect     = work.KeepDisplayAspect;
            profile.LargeFile             = work.LargeFile;
            profile.MaxHeight             = work.MaxHeight.HasValue ? work.MaxHeight.Value : 0;
            profile.MaxWidth              = work.MaxWidth.HasValue ? work.MaxWidth.Value : 0;
            profile.Modulus               = work.Modulus.HasValue ? work.Modulus.Value : 16;
            profile.Optimize              = work.OptimizeMP4;
            switch (work.OutputFormat)
            {
            case OutputFormat.Mp4:
            case OutputFormat.M4V:
                profile.OutputFormat = Container.Mp4;
                break;

            case OutputFormat.Mkv:
                profile.OutputFormat = Container.Mkv;
                break;
            }
            profile.ConstantFramerate = work.FramerateMode == FramerateMode.CFR;
            profile.PixelAspectX      = work.PixelAspectX;
            profile.PixelAspectY      = work.PixelAspectY;

            switch (work.OutputFormat)
            {
            case OutputFormat.Mp4:
                profile.PreferredExtension = OutputExtension.Mp4;
                break;

            case OutputFormat.M4V:
                profile.PreferredExtension = OutputExtension.M4v;
                break;
            }
            profile.Quality             = work.Quality.HasValue ? work.Quality.Value : 0;
            profile.UseDisplayWidth     = true;
            profile.VideoBitrate        = work.VideoBitrate.HasValue ? work.VideoBitrate.Value : 0;
            profile.VideoEncodeRateType = work.VideoEncodeRateType;
            profile.VideoEncoder        = Converters.GetVideoEncoder(work.VideoEncoder);
            profile.Width       = work.Width.HasValue ? work.Width.Value : 0;
            profile.X264Options = work.AdvancedEncoderOptions;

            if (work.PointToPointMode == PointToPointMode.Chapters)
            {
                job.ChapterStart = work.StartPoint;
                job.ChapterEnd   = work.EndPoint;
            }

            job.Angle           = work.Angle;
            job.EncodingProfile = profile;
            if (work.PointToPointMode == PointToPointMode.Frames)
            {
                job.FramesEnd   = work.EndPoint;
                job.FramesStart = work.StartPoint;
            }

            job.CustomChapterNames     = work.ChapterNames.Select(item => item.ChapterName).ToList();
            job.UseDefaultChapterNames = work.IncludeChapterMarkers;

            job.OutputPath = work.Destination;
            switch (work.PointToPointMode)
            {
            case PointToPointMode.Chapters:
                job.RangeType = VideoRangeType.Chapters;
                break;

            case PointToPointMode.Seconds:
                job.RangeType = VideoRangeType.Seconds;
                break;

            case PointToPointMode.Frames:
                job.RangeType = VideoRangeType.Frames;
                break;
            }

            if (work.PointToPointMode == PointToPointMode.Seconds)
            {
                job.SecondsEnd   = work.EndPoint;
                job.SecondsStart = work.StartPoint;
            }

            job.SourcePath = work.Source;
            // job.SourceType = work.Type;
            job.Title = work.Title;

            // Subtitles
            job.Subtitles = new Subtitles {
                SourceSubtitles = new List <SourceSubtitle>(), SrtSubtitles = new List <SrtSubtitle>()
            };
            foreach (SubtitleTrack track in work.SubtitleTracks)
            {
                if (track.IsSrtSubtitle)
                {
                    job.Subtitles.SrtSubtitles.Add(
                        new SrtSubtitle
                    {
                        CharacterCode = track.SrtCharCode,
                        Default       = track.Default,
                        FileName      = track.SrtFileName,
                        LanguageCode  = track.SrtLang,
                        Offset        = track.SrtOffset
                    });
                }
                else
                {
                    if (track.SourceTrack != null)
                    {
                        job.Subtitles.SourceSubtitles.Add(
                            new SourceSubtitle
                        {
                            BurnedIn    = track.Burned,
                            Default     = track.Default,
                            Forced      = track.Forced,
                            TrackNumber = track.SourceTrack.TrackNumber
                        });
                    }
                }
            }

            return(job);
        }
        /// <summary>
        /// Get an EncodeJob model for a LibHB Encode.
        /// </summary>
        /// <param name="task">
        /// The task.
        /// </param>
        /// <param name="configuration">
        /// The configuration.
        /// </param>
        /// <returns>
        /// An Interop.EncodeJob model.
        /// </returns>
        public static EncodeJob GetEncodeJob(EncodeTask task, HBConfiguration configuration)
        {
            // The current Job Configuration
            EncodeTask work = task;

            // Which will be converted to this EncodeJob Model.
            EncodeJob job = new EncodeJob();

            // Audio Settings
            job.AudioEncodings = new List <AudioEncoding>();
            foreach (AudioTrack track in work.AudioTracks)
            {
                AudioEncoding newTrack = new AudioEncoding
                {
                    Bitrate        = track.Bitrate,
                    Drc            = track.DRC,
                    Gain           = track.Gain,
                    Encoder        = Converters.GetCliAudioEncoder(track.Encoder),
                    InputNumber    = track.Track.HasValue ? track.Track.Value : 0,
                    Mixdown        = Converters.GetCliMixDown(track.MixDown),
                    SampleRateRaw  = GetSampleRateRaw(track.SampleRate),
                    EncodeRateType = AudioEncodeRateType.Bitrate,
                    Name           = track.TrackName,
                    IsPassthru     = track.IsPassthru,
                };

                job.AudioEncodings.Add(newTrack);
            }

            // Title Settings
            job.OutputPath = work.Destination;
            job.SourcePath = work.Source;
            job.Title      = work.Title;

            // job.SourceType = work.Type;
            switch (work.PointToPointMode)
            {
            case PointToPointMode.Chapters:
                job.RangeType = VideoRangeType.Chapters;
                break;

            case PointToPointMode.Seconds:
                job.RangeType = VideoRangeType.Seconds;
                break;

            case PointToPointMode.Frames:
                job.RangeType = VideoRangeType.Frames;
                break;

            case PointToPointMode.Preview:
                job.RangeType = VideoRangeType.Preview;
                break;
            }

            if (work.PointToPointMode == PointToPointMode.Seconds)
            {
                job.SecondsEnd   = work.EndPoint;
                job.SecondsStart = work.StartPoint;
            }
            if (work.PointToPointMode == PointToPointMode.Chapters)
            {
                job.ChapterStart = work.StartPoint;
                job.ChapterEnd   = work.EndPoint;
            }
            if (work.PointToPointMode == PointToPointMode.Frames)
            {
                job.FramesEnd   = work.EndPoint;
                job.FramesStart = work.StartPoint;
            }

            if (work.PointToPointMode == PointToPointMode.Preview)
            {
                job.StartAtPreview = work.PreviewEncodeStartAt.HasValue ? work.PreviewEncodeStartAt.Value + 1 : 1;
                job.SecondsEnd     = work.PreviewEncodeDuration.HasValue ? work.PreviewEncodeDuration.Value : 30;
                job.SeekPoints     = configuration.PreviewScanCount;
            }

            job.Angle = work.Angle;

            // Output Settings
            job.IPod5GSupport = work.IPod5GSupport;
            job.Optimize      = work.OptimizeMP4;
            switch (work.OutputFormat)
            {
            case OutputFormat.Mp4:
                job.ContainerName = "av_mp4";     // TODO make part of enum.
                break;

            case OutputFormat.Mkv:
                job.ContainerName = "av_mkv";     // TODO make part of enum.
                break;
            }

            // Picture Settings
            job.Anamorphic = work.Anamorphic;
            job.Cropping   = new Cropping {
                Top = work.Cropping.Top, Bottom = work.Cropping.Bottom, Left = work.Cropping.Left, Right = work.Cropping.Right
            };
            job.DisplayWidth      = work.DisplayWidth.HasValue ? int.Parse(Math.Round(work.DisplayWidth.Value, 0).ToString()) : 0;
            job.PixelAspectX      = work.PixelAspectX;
            job.PixelAspectY      = work.PixelAspectY;
            job.Height            = work.Height.HasValue ? work.Height.Value : 0;
            job.KeepDisplayAspect = work.KeepDisplayAspect;
            job.MaxHeight         = work.MaxHeight.HasValue ? work.MaxHeight.Value : 0;
            job.MaxWidth          = work.MaxWidth.HasValue ? work.MaxWidth.Value : 0;
            job.Modulus           = work.Modulus.HasValue ? work.Modulus.Value : 16;
            job.UseDisplayWidth   = true;
            job.Width             = work.Width.HasValue ? work.Width.Value : 0;

            // Filter Settings
            job.CustomDecomb      = work.CustomDecomb;
            job.CustomDeinterlace = work.CustomDeinterlace;
            job.CustomDenoise     = work.CustomDenoise;
            job.DenoisePreset     = work.DenoisePreset.ToString().ToLower().Replace(" ", string.Empty);
            job.DenoiseTune       = work.DenoiseTune.ToString().ToLower().Replace(" ", string.Empty);
            job.CustomDetelecine  = work.CustomDetelecine;
            if (work.Deblock > 4)
            {
                job.Deblock = work.Deblock;
            }
            job.Decomb      = work.Decomb;
            job.Deinterlace = work.Deinterlace;
            job.Denoise     = work.Denoise;
            job.Detelecine  = work.Detelecine;
            job.Grayscale   = work.Grayscale;

            // Video Settings
            job.Framerate           = work.Framerate.HasValue ? work.Framerate.Value : 0;
            job.ConstantFramerate   = work.FramerateMode == FramerateMode.CFR;
            job.PeakFramerate       = work.FramerateMode == FramerateMode.PFR;
            job.Quality             = work.Quality.HasValue ? work.Quality.Value : 0;
            job.VideoBitrate        = work.VideoBitrate.HasValue ? work.VideoBitrate.Value : 0;
            job.VideoEncodeRateType = work.VideoEncodeRateType;
            job.VideoEncoder        = Converters.GetVideoEncoder(work.VideoEncoder);
            job.TwoPass             = work.TwoPass;
            job.TurboFirstPass      = work.TurboFirstPass;

            if (work.VideoEncoder == VideoEncoder.X264 || work.VideoEncoder == VideoEncoder.X265 || work.VideoEncoder == VideoEncoder.QuickSync)
            {
                job.VideoPreset  = work.VideoPreset.ShortName;
                job.VideoProfile = work.VideoProfile.ShortName;
                job.VideoLevel   = work.VideoLevel.ShortName;

                if (work.VideoEncoder != VideoEncoder.QuickSync)
                {
                    job.VideoTunes = new List <string>();
                    foreach (var item in work.VideoTunes)
                    {
                        job.VideoTunes.Add(item.ShortName);
                    }
                }
            }

            // Chapter Markers
            job.IncludeChapterMarkers  = work.IncludeChapterMarkers;
            job.CustomChapterNames     = work.ChapterNames.Select(item => item.ChapterName).ToList();
            job.UseDefaultChapterNames = work.IncludeChapterMarkers;

            // Advanced Settings
            job.VideoOptions = work.ShowAdvancedTab ? work.AdvancedEncoderOptions : work.ExtraAdvancedArguments;

            // Subtitles
            job.Subtitles = new Subtitles {
                SourceSubtitles = new List <SourceSubtitle>(), SrtSubtitles = new List <SrtSubtitle>()
            };
            foreach (SubtitleTrack track in work.SubtitleTracks)
            {
                if (track.IsSrtSubtitle)
                {
                    job.Subtitles.SrtSubtitles.Add(
                        new SrtSubtitle
                    {
                        CharacterCode = track.SrtCharCode,
                        Default       = track.Default,
                        FileName      = track.SrtPath,
                        LanguageCode  = track.SrtLang,
                        Offset        = track.SrtOffset,
                        BurnedIn      = track.Burned
                    });
                }
                else
                {
                    if (track.SourceTrack != null)
                    {
                        job.Subtitles.SourceSubtitles.Add(
                            new SourceSubtitle {
                            BurnedIn = track.Burned, Default = track.Default, Forced = track.Forced, TrackNumber = track.SourceTrack.TrackNumber
                        });
                    }
                }
            }

            return(job);
        }