private static bool CheckSubStreamCount(SVR_VideoLocal file)
        {
            int streamCount = file?.Media?.TextStreams.Count ?? -1;

            if (streamCount == -1)
            {
                return(true);
            }

            FileQualityFilterOperationType operationType = Settings.RequiredSubStreamCount.Operator;

            switch (operationType)
            {
            case FileQualityFilterOperationType.EQUALS:
                return(streamCount == Settings.RequiredSubStreamCount.Value);

            case FileQualityFilterOperationType.GREATER_EQ:
                return(streamCount >= Settings.RequiredSubStreamCount.Value);

            case FileQualityFilterOperationType.LESS_EQ:
                return(streamCount <= Settings.RequiredSubStreamCount.Value);
            }

            return(true);
        }
        private static bool CheckSubGroup(AniDB_File aniFile)
        {
            FileQualityFilterOperationType operationType = Settings.RequiredSubGroupOperator;

            switch (operationType)
            {
            case FileQualityFilterOperationType.IN:
                return(Settings._requiredsubgroups.Item1.Contains(aniFile.Anime_GroupName.ToLowerInvariant()) ||
                       Settings._requiredsubgroups.Item1.Contains(aniFile.Anime_GroupNameShort.ToLowerInvariant()));

            case FileQualityFilterOperationType.NOTIN:
                return(!Settings._requiredsubgroups.Item1.Contains(aniFile.Anime_GroupName.ToLowerInvariant()) &&
                       !Settings._requiredsubgroups.Item1.Contains(aniFile.Anime_GroupNameShort.ToLowerInvariant()));
            }
            return(true);
        }
        private static bool CheckSubStreamCount(SVR_VideoLocal file)
        {
            int streamCount = file.Media.Parts.SelectMany(a => a.Streams).Count(b => b.StreamType == "3");
            FileQualityFilterOperationType operationType = Settings.RequiredSubStreamCountOperator;

            switch (operationType)
            {
            case FileQualityFilterOperationType.EQUALS:
                return(streamCount == Settings.RequiredSubStreamCount);

            case FileQualityFilterOperationType.GREATER_EQ:
                return(streamCount >= Settings.RequiredSubStreamCount);

            case FileQualityFilterOperationType.LESS_EQ:
                return(streamCount <= Settings.RequiredSubStreamCount);
            }
            return(true);
        }
        private static bool CheckSource(AniDB_File aniFile)
        {
            if (string.IsNullOrEmpty(aniFile.File_Source))
            {
                return(false);
            }
            FileQualityFilterOperationType operationType = Settings.RequiredSourceOperator;

            switch (operationType)
            {
            case FileQualityFilterOperationType.IN:
                return(Settings._requiredsources.Item1.Contains(aniFile.File_Source.ToLowerInvariant()));

            case FileQualityFilterOperationType.NOTIN:
                return(!Settings._requiredsources.Item1.Contains(aniFile.File_Source.ToLowerInvariant()));
            }
            return(true);
        }
Exemple #5
0
        private static bool CheckVideoCodec(AniDB_File aniFile)
        {
            string[] codecs = aniFile.File_VideoCodec.ToLowerInvariant()
                              .Split(new[] { '\'' }, StringSplitOptions.RemoveEmptyEntries);
            if (codecs.Length == 0)
            {
                return(false);
            }
            FileQualityFilterOperationType operationType = Settings.RequiredVideoCodecOperator;

            switch (operationType)
            {
            case FileQualityFilterOperationType.IN:
                return(Settings._requiredvideocodecs.Item1.FindInEnumerable(codecs));

            case FileQualityFilterOperationType.NOTIN:
                return(!Settings._requiredvideocodecs.Item1.FindInEnumerable(codecs));
            }
            return(true);
        }
Exemple #6
0
        private static bool CheckAudioStreamCount(AniDB_File aniFile)
        {
            int streamCount = aniFile.File_AudioCodec.ToLowerInvariant()
                              .Split(new[] { '\'' }, StringSplitOptions.RemoveEmptyEntries)
                              .Length;
            FileQualityFilterOperationType operationType = Settings.RequiredAudioStreamCountOperator;

            switch (operationType)
            {
            case FileQualityFilterOperationType.EQUALS:
                return(streamCount == Settings.RequiredAudioStreamCount);

            case FileQualityFilterOperationType.GREATER_EQ:
                return(streamCount >= Settings.RequiredAudioStreamCount);

            case FileQualityFilterOperationType.LESS_EQ:
                return(streamCount <= Settings.RequiredAudioStreamCount);
            }
            return(true);
        }
        private static bool CheckSubGroup(AniDB_File aniFile)
        {
            if (IsNullOrUnknown(aniFile))
            {
                return(false);
            }
            FileQualityFilterOperationType operationType = Settings.RequiredSubGroups.Operator;

            switch (operationType)
            {
            case FileQualityFilterOperationType.IN:
                return(Settings.RequiredSubGroups.Value.Contains(aniFile.Anime_GroupName.ToLowerInvariant()) ||
                       Settings.RequiredSubGroups.Value.Contains(aniFile.Anime_GroupNameShort.ToLowerInvariant()));

            case FileQualityFilterOperationType.NOTIN:
                return(!Settings.RequiredSubGroups.Value.Contains(aniFile.Anime_GroupName.ToLowerInvariant()) &&
                       !Settings.RequiredSubGroups.Value.Contains(aniFile.Anime_GroupNameShort.ToLowerInvariant()));
            }

            return(true);
        }
        private static bool CheckVideoCodec(SVR_VideoLocal aniFile)
        {
            string[] codecs = aniFile.Media.Parts.SelectMany(a => a.Streams)
                              .Where(a => a.StreamType == "1")
                              .Select(a => a.Codec)
                              .OrderBy(a => a)
                              .ToArray();
            if (codecs.Length == 0)
            {
                return(false);
            }
            FileQualityFilterOperationType operationType = Settings.RequiredVideoCodecOperator;

            switch (operationType)
            {
            case FileQualityFilterOperationType.IN:
                return(Settings._requiredvideocodecs.Item1.FindInEnumerable(codecs));

            case FileQualityFilterOperationType.NOTIN:
                return(!Settings._requiredvideocodecs.Item1.FindInEnumerable(codecs));
            }
            return(true);
        }
Exemple #9
0
        private static bool CheckSource(AniDB_File aniFile)
        {
            if (IsNullOrUnknown(aniFile))
            {
                return(false);
            }
            FileQualityFilterOperationType operationType = Settings.RequiredSourceOperator;
            var source = aniFile.File_Source.ToLowerInvariant();

            if (FileQualityPreferences.SimplifiedSources.ContainsKey(source))
            {
                source = FileQualityPreferences.SimplifiedSources[source];
            }
            switch (operationType)
            {
            case FileQualityFilterOperationType.IN:
                return(Settings._requiredsources.Item1.Contains(source));

            case FileQualityFilterOperationType.NOTIN:
                return(!Settings._requiredsources.Item1.Contains(source));
            }
            return(true);
        }
        private static bool CheckAudioCodec(SVR_VideoLocal aniFile)
        {
            string[] codecs =
                aniFile?.Media?.AudioStreams.Select(LegacyMediaUtils.TranslateCodec).OrderBy(a => a)
                .ToArray() ?? new string[] { };
            if (codecs.Length == 0)
            {
                return(false);
            }

            FileQualityFilterOperationType operationType = Settings.RequiredAudioCodecs.Operator;

            switch (operationType)
            {
            case FileQualityFilterOperationType.IN:
                return(codecs.FindInEnumerable(Settings.RequiredAudioCodecs.Value));

            case FileQualityFilterOperationType.NOTIN:
                return(!codecs.FindInEnumerable(Settings.RequiredAudioCodecs.Value));
            }

            return(true);
        }
        private static bool CheckAudioStreamCount(SVR_VideoLocal aniFile)
        {
            int streamCount = aniFile?.Media?.Parts?.SelectMany(a => a.Streams).Count(a => a.StreamType == 2) ?? -1;

            if (streamCount == -1)
            {
                return(true);
            }

            FileQualityFilterOperationType operationType = Settings.RequiredAudioStreamCountOperator;

            switch (operationType)
            {
            case FileQualityFilterOperationType.EQUALS:
                return(streamCount == Settings.RequiredAudioStreamCount);

            case FileQualityFilterOperationType.GREATER_EQ:
                return(streamCount >= Settings.RequiredAudioStreamCount);

            case FileQualityFilterOperationType.LESS_EQ:
                return(streamCount <= Settings.RequiredAudioStreamCount);
            }
            return(true);
        }
        private static bool CheckAudioCodec(SVR_VideoLocal aniFile)
        {
            string[] codecs = aniFile?.Media?.Parts?.SelectMany(a => a.Streams)
                              .Where(a => a.StreamType == 2)
                              .Select(a => a.Codec)
                              .OrderBy(a => a)
                              .ToArray() ?? new string[] {};
            if (codecs.Length == 0)
            {
                return(false);
            }

            FileQualityFilterOperationType operationType = Settings.RequiredAudioCodecOperator;

            switch (operationType)
            {
            case FileQualityFilterOperationType.IN:
                return(codecs.FindInEnumerable(Settings._requiredaudiocodecs.Item1));

            case FileQualityFilterOperationType.NOTIN:
                return(!codecs.FindInEnumerable(Settings._requiredaudiocodecs.Item1));
            }
            return(true);
        }
        private static bool CheckResolution(SVR_VideoLocal videoLocal, SVR_AniDB_File aniFile)
        {
            Tuple <int, int> resTuple = GetResolutionInternal(videoLocal, aniFile);
            string           res      = GetResolution(resTuple);

            if (res == null)
            {
                return(false);
            }

            int resArea = resTuple.Item1 * resTuple.Item2;

            FileQualityFilterOperationType operationType = Settings.RequiredResolutionOperator;

            switch (operationType)
            {
            case FileQualityFilterOperationType.EQUALS:
                return(res.Equals(Settings.RequiredResolutions.FirstOrDefault()));

            case FileQualityFilterOperationType.GREATER_EQ:
                List <int> keysGT = ResolutionArea.Keys.Where(a => resArea >= a).ToList();
                keysGT.AddRange(ResolutionAreaOld.Keys.Where(a => resArea >= a));
                List <string> valuesGT = new List <string>();
                foreach (int key in keysGT)
                {
                    if (ResolutionArea.ContainsKey(key))
                    {
                        valuesGT.Add(ResolutionArea[key]);
                    }
                    if (ResolutionAreaOld.ContainsKey(key))
                    {
                        valuesGT.Add(ResolutionAreaOld[key]);
                    }
                }
                if (valuesGT.FindInEnumerable(Settings.RequiredResolutions))
                {
                    return(true);
                }
                break;

            case FileQualityFilterOperationType.LESS_EQ:
                List <int> keysLT = ResolutionArea.Keys.Where(a => resArea <= a).ToList();
                keysLT.AddRange(ResolutionAreaOld.Keys.Where(a => resArea <= a));
                List <string> valuesLT = new List <string>();
                foreach (int key in keysLT)
                {
                    if (ResolutionArea.ContainsKey(key))
                    {
                        valuesLT.Add(ResolutionArea[key]);
                    }
                    if (ResolutionAreaOld.ContainsKey(key))
                    {
                        valuesLT.Add(ResolutionAreaOld[key]);
                    }
                }
                if (valuesLT.FindInEnumerable(Settings.RequiredResolutions))
                {
                    return(true);
                }
                break;

            case FileQualityFilterOperationType.IN:
                return(Settings.RequiredResolutions.Contains(res));

            case FileQualityFilterOperationType.NOTIN:
                return(!Settings.RequiredResolutions.Contains(res));
            }
            return(false);
        }