void healthMonitor_ReportSampledData(object sender, SimpleEventArgs <SampleData> e)
 {
     try
     {
         if (e.Result is QualityData)
         {
             QualityData data = (QualityData)e.Result;
             if (data.IsSnapshot)
             {
                 ReportSnapshotData(data);
             }
             else
             {
                 ReportQualityData(data);
             }
         }
         else if (e.Result is DownloadErrorAggregatedData)
         {
             ReportDownloadErrorData((DownloadErrorAggregatedData)e.Result);
         }
     }
     catch (Exception ex)
     {
         LoggingService.Current.BroadcastException(ex);
     }
 }
    public static void LoadSettings()
    {
        if (File.Exists(PATH))
        {
            using (StreamReader reader = File.OpenText(PATH))
            {
                string jsonString = reader.ReadToEnd();
                DATA = JsonUtility.FromJson <QualityData>(jsonString);
                Debug.Log(PATH + " loaded successfully.");
            }
        }
        else
        {
            Debug.Log(PATH + " not found, using default quality settings...");
            switch (Graphics.activeTier)
            {
            case UnityEngine.Rendering.GraphicsTier.Tier1: DATA.SHADER_GRAPHICS_TIER = 1; break;

            case UnityEngine.Rendering.GraphicsTier.Tier2: DATA.SHADER_GRAPHICS_TIER = 2; break;

            case UnityEngine.Rendering.GraphicsTier.Tier3: DATA.SHADER_GRAPHICS_TIER = 3; break;
            }
            SaveSettings();
        }
        ApplySettings();
    }
Exemple #3
0
        /// <summary>
        /// Compute static BCT
        /// </summary>
        public static double ComputeStaticBCT(
            double length, double width, double height
            , string cardboardId, string caseType
            , FormulaType mcKeeFormulaType)
        {
            if (!McKeeFormula.CardboardQualityDictionary.ContainsKey(cardboardId))
            {
                throw new Exception(Exception.ErrorType.ERROR_INVALIDCARDBOARD, cardboardId);
            }
            QualityData qualityData = McKeeFormula.CardboardQualityDictionary[cardboardId];

            if (!McKeeFormula.CaseTypeDictionary.ContainsKey(caseType))
            {
                throw new Exception(Exception.ErrorType.ERROR_INVALIDCASETYPE, caseType);
            }
            double caseTypeCoef = McKeeFormula.CaseTypeDictionary[caseType];

            switch (mcKeeFormulaType)
            {
            case FormulaType.MCKEE_CLASSIC:
                return(McKeeFormula.ComputeBCT_ECT(length, width, qualityData.Thickness, qualityData.ECT) * caseTypeCoef);

            case FormulaType.MCKEE_IMPROVED:
                return(McKeeFormula.ComputeBCT_Stiffness(length, width, height,
                                                         qualityData.Thickness, qualityData.RigidityDX, qualityData.RigidityDY,
                                                         qualityData.ECT) * caseTypeCoef);

            default:
                throw new TreeDim.EdgeCrushTest.Exception(Exception.ErrorType.ERROR_INVALIDFORMULATYPE, string.Empty);
            }
        }
        void ReportSnapshotData(QualityData data)
        {
            VideoQualitySnapshotLog qualityLog = new VideoQualitySnapshotLog();

            PopulateQualityLog(data, qualityLog);
            SendLog(qualityLog);
        }
 public QualityData(QualityData data)
 {
     _name       = data._name;
     _thickness  = data._thickness;
     _ECT        = data._ECT;
     _rigidityDX = data._rigidityDX;
     _rigidityDY = data._rigidityDY;
 }
Exemple #6
0
 public QualityData(QualityData data)
 {
     _name = data._name;
     _thickness = data._thickness;
     _ECT = data._ECT;
     _rigidityDX = data._rigidityDX;
     _rigidityDY = data._rigidityDY;
 }
    public void SetGlobalValues()
    {
        QualityData selectedQuality = currentQualities[qualitySettings.value];

        textureQuality.value      = selectedQuality.textureQuality;
        antialiasing.value        = (int)selectedQuality.antialiasingValues;
        anisotropicTextures.value = selectedQuality.anisotropic;
        vsync.value = selectedQuality.vsync;
    }
Exemple #8
0
 private void OnWizardUpdate()
 {
     if (data == null)
     {
         if (QualityManager.DATA == null)
         {
             Debug.LogWarning("Initializing QualityManager...");
             QualityManager.LoadSettings();
         }
         data = QualityManager.DATA;
     }
 }
                public static QualityData Parse(XmlNode qualityDataNode)
                {
                    var downlinkQualityNode        = qualityDataNode.SelectSingleNodeThrowIfNull("downlinkQuality");
                    var rawDataAnalysisQualityNode = qualityDataNode.SelectSingleNodeThrowIfNull("rawDataAnalysisQuality");
                    var dopplerCentroidQualityNode = qualityDataNode.SelectSingleNodeThrowIfNull("dopplerCentroidQuality");
                    var imageQualityNode           = qualityDataNode.SelectSingleNodeThrowIfNull("imageQuality");

                    var data = new QualityData();

                    data.AzimuthTime = DateTimeOffset.Parse(qualityDataNode.SelectSingleNodeThrowIfNull("azimuthTime").InnerText);

                    data.DownlinkQuality = new DownlinkQuality();
                    data.DownlinkQuality.IInputDataMean = double.Parse(downlinkQualityNode.SelectSingleNodeThrowIfNull("iInputDataMean").InnerText);
                    data.DownlinkQuality.QInputDataMean = double.Parse(downlinkQualityNode.SelectSingleNodeThrowIfNull("qInputDataMean").InnerText);
                    data.DownlinkQuality.InputDataMeanOutsideNorminalRange = bool.Parse(downlinkQualityNode.SelectSingleNodeThrowIfNull("inputDataMeanOutsideNominalRangeFlag").InnerText);
                    data.DownlinkQuality.IInputDataStdDev = double.Parse(downlinkQualityNode.SelectSingleNodeThrowIfNull("iInputDataStdDev").InnerText);
                    data.DownlinkQuality.QInputDataStdDev = double.Parse(downlinkQualityNode.SelectSingleNodeThrowIfNull("qInputDataStdDev").InnerText);
                    data.DownlinkQuality.InputDataStDevOutsideNominalRange    = bool.Parse(downlinkQualityNode.SelectSingleNodeThrowIfNull("inputDataStDevOutsideNominalRangeFlag").InnerText);
                    data.DownlinkQuality.DownlinkInputDataGaps                = int.Parse(downlinkQualityNode.SelectSingleNodeThrowIfNull("numDownlinkInputDataGaps").InnerText);
                    data.DownlinkQuality.DownlinkGapsInInputDataSignificant   = bool.Parse(downlinkQualityNode.SelectSingleNodeThrowIfNull("downlinkGapsInInputDataSignificantFlag").InnerText);
                    data.DownlinkQuality.DownlinkInputMissingLines            = int.Parse(downlinkQualityNode.SelectSingleNodeThrowIfNull("numDownlinkInputMissingLines").InnerText);
                    data.DownlinkQuality.DownlinkMissingLinesSignificant      = bool.Parse(downlinkQualityNode.SelectSingleNodeThrowIfNull("downlinkMissingLinesSignificantFlag").InnerText);
                    data.DownlinkQuality.InstrumentInputDataGaps              = int.Parse(downlinkQualityNode.SelectSingleNodeThrowIfNull("numInstrumentInputDataGaps").InnerText);
                    data.DownlinkQuality.InstrumentGapsInInputDataSignificant = bool.Parse(downlinkQualityNode.SelectSingleNodeThrowIfNull("instrumentGapsInInputDataSignificantFlag").InnerText);
                    data.DownlinkQuality.InstrumentInputMissingLines          = int.Parse(downlinkQualityNode.SelectSingleNodeThrowIfNull("numInstrumentInputMissingLines").InnerText);
                    data.DownlinkQuality.InstrumentMissingLinesSignificant    = bool.Parse(downlinkQualityNode.SelectSingleNodeThrowIfNull("instrumentMissingLinesSignificantFlag").InnerText);
                    data.DownlinkQuality.SsbErrorInputDataGaps                = int.Parse(downlinkQualityNode.SelectSingleNodeThrowIfNull("numSsbErrorInputDataGaps").InnerText);
                    data.DownlinkQuality.SsbErrorGapsInInputDataSignificant   = bool.Parse(downlinkQualityNode.SelectSingleNodeThrowIfNull("ssbErrorGapsInInputDataSignificantFlag").InnerText);
                    data.DownlinkQuality.SsbErrorInputMissingLines            = int.Parse(downlinkQualityNode.SelectSingleNodeThrowIfNull("numSsbErrorInputMissingLines").InnerText);
                    data.DownlinkQuality.SsbErrorMissingLinesSignificant      = bool.Parse(downlinkQualityNode.SelectSingleNodeThrowIfNull("ssbErrorMissingLinesSignificantFlag").InnerText);
                    data.DownlinkQuality.ChirpSourceUsed             = (ChirpSourceType)Enum.Parse(typeof(ChirpSourceType), downlinkQualityNode.SelectSingleNodeThrowIfNull("chirpSourceUsed").InnerText);
                    data.DownlinkQuality.PgSourceUsed                = (PgSourceType)Enum.Parse(typeof(PgSourceType), downlinkQualityNode.SelectSingleNodeThrowIfNull("pgSourceUsed").InnerText);
                    data.DownlinkQuality.RrfSpectrumUsed             = (RrfSpectrumType)Enum.Parse(typeof(RrfSpectrumType), downlinkQualityNode.SelectSingleNodeThrowIfNull("rrfSpectrumUsed").InnerText.RemoveWhitespaces());
                    data.DownlinkQuality.ReplicaReconstructionFailed = bool.Parse(downlinkQualityNode.SelectSingleNodeThrowIfNull("replicaReconstructionFailedFlag").InnerText);
                    data.DownlinkQuality.MeanPgProductAmplitude      = double.Parse(downlinkQualityNode.SelectSingleNodeThrowIfNull("meanPgProductAmplitude").InnerText);
                    data.DownlinkQuality.StdDevPgProductAmplitude    = double.Parse(downlinkQualityNode.SelectSingleNodeThrowIfNull("stdDevPgProductAmplitude").InnerText);
                    data.DownlinkQuality.MeanPgProductPhase          = double.Parse(downlinkQualityNode.SelectSingleNodeThrowIfNull("meanPgProductPhase").InnerText);
                    data.DownlinkQuality.StdDevPgProductPhase        = double.Parse(downlinkQualityNode.SelectSingleNodeThrowIfNull("stdDevPgProductPhase").InnerText);
                    data.DownlinkQuality.PgProductDerivationFailed   = bool.Parse(downlinkQualityNode.SelectSingleNodeThrowIfNull("pgProductDerivationFailedFlag").InnerText);
                    data.DownlinkQuality.InvalidDownlinkParams       = bool.Parse(downlinkQualityNode.SelectSingleNodeThrowIfNull("invalidDownlinkParamsFlag").InnerText);

                    data.RawDataAnalysisQuality                                   = new RawDataAnalysisQuality();
                    data.RawDataAnalysisQuality.IBias                             = double.Parse(rawDataAnalysisQualityNode.SelectSingleNodeThrowIfNull("iBias").InnerText);
                    data.RawDataAnalysisQuality.IBiasSignificance                 = bool.Parse(rawDataAnalysisQualityNode.SelectSingleNodeThrowIfNull("iBiasSignificanceFlag").InnerText);
                    data.RawDataAnalysisQuality.QBias                             = double.Parse(rawDataAnalysisQualityNode.SelectSingleNodeThrowIfNull("qBias").InnerText);
                    data.RawDataAnalysisQuality.QBiasSignificance                 = bool.Parse(rawDataAnalysisQualityNode.SelectSingleNodeThrowIfNull("qBiasSignificanceFlag").InnerText);
                    data.RawDataAnalysisQuality.IQGainImbalance                   = double.Parse(rawDataAnalysisQualityNode.SelectSingleNodeThrowIfNull("iqGainImbalance").InnerText);
                    data.RawDataAnalysisQuality.IQGainSignificance                = bool.Parse(rawDataAnalysisQualityNode.SelectSingleNodeThrowIfNull("iqGainSignificanceFlag").InnerText);
                    data.RawDataAnalysisQuality.IqQuadratureDeparture             = double.Parse(rawDataAnalysisQualityNode.SelectSingleNodeThrowIfNull("iqQuadratureDeparture").InnerText);
                    data.RawDataAnalysisQuality.IqQuadratureDepartureSignificance = bool.Parse(rawDataAnalysisQualityNode.SelectSingleNodeThrowIfNull("iqQuadratureDepartureSignificanceFlag").InnerText);

                    data.DopplerCentroidQuality          = new DopplerCentroidQuality();
                    data.DopplerCentroidQuality.DcMethod = (DcMethodType)Enum.Parse(typeof(DcMethodType), dopplerCentroidQualityNode.SelectSingleNodeThrowIfNull("dcMethod").InnerText.RemoveWhitespaces());
                    data.DopplerCentroidQuality.DopplerCentroidUncertain = bool.Parse(dopplerCentroidQualityNode.SelectSingleNodeThrowIfNull("dopplerCentroidUncertainFlag").InnerText);

                    data.ImageQuality = new ImageQuality();
                    data.ImageQuality.ImageStatistics = new ImageQualityStatistics();
                    data.ImageQuality.ImageStatistics.OutputDataMeanRe   = double.Parse(imageQualityNode.SelectSingleNodeThrowIfNull("imageStatistics/outputDataMean/re").InnerText);
                    data.ImageQuality.ImageStatistics.OutputDataMeanIm   = double.Parse(imageQualityNode.SelectSingleNodeThrowIfNull("imageStatistics/outputDataMean/im").InnerText);
                    data.ImageQuality.ImageStatistics.OutputDataStdDevRe = double.Parse(imageQualityNode.SelectSingleNodeThrowIfNull("imageStatistics/outputDataStdDev/re").InnerText);
                    data.ImageQuality.ImageStatistics.OutputDataStdDevIm = double.Parse(imageQualityNode.SelectSingleNodeThrowIfNull("imageStatistics/outputDataStdDev/im").InnerText);
                    data.ImageQuality.OutputDataMeanOutsideNominalRange  = bool.Parse(imageQualityNode.SelectSingleNodeThrowIfNull("outputDataMeanOutsideNominalRangeFlag").InnerText);
                    data.ImageQuality.OutputDataStDevOutsideNominalRange = bool.Parse(imageQualityNode.SelectSingleNodeThrowIfNull("outputDataStDevOutsideNominalRangeFlag").InnerText);

                    return(data);
                }
        private void PopulateQualityLog(QualityData data, VideoQualityBaseLog qualityLog)
        {
            PopulateVideoEventLog(qualityLog);
            qualityLog.VideoUrl                 = data.CurrentStreamUrl;
            qualityLog.EdgeIP                   = healthMonitor.EdgeServer;
            qualityLog.ClientIP                 = healthMonitor.ClientIP;
            qualityLog.MediaElementId           = data.MediaElementId;
            qualityLog.SamplingFrequencySeconds = data.SampleSizeMilliseconds / 1000;
            qualityLog.IsLive                   = data.IsLive;
            qualityLog.TotalElapsedTime         = healthMonitor.VideoSessionTotalTime.TotalSeconds;
            if (data.Bitrate.HasValue)
            {
                qualityLog.BitRate = Convert.ToInt32(data.Bitrate.Value);
            }
            if (data.BitrateChangeCount.HasValue)
            {
                qualityLog.BitRateChangeCount = data.BitrateChangeCount.Value;
            }
            if (data.BitrateMax.HasValue)
            {
                qualityLog.MaxBitRate = data.BitrateMax.Value;
            }
            if (data.BitrateMaxMilliseconds.HasValue)
            {
                qualityLog.MaxBitRateMilliseconds = Convert.ToInt32(data.BitrateMaxMilliseconds.Value);
            }
            if (data.BufferingMilliseconds.HasValue)
            {
                qualityLog.BufferingMilliseconds = Convert.ToInt32(data.BufferingMilliseconds.Value);
            }
            if (data.ProcessCpuLoad.HasValue)
            {
                qualityLog.ProcessCPULoad = Convert.ToInt16(data.ProcessCpuLoad.Value);
            }
            if (data.SystemCpuLoad.HasValue)
            {
                qualityLog.SystemCPULoad = Convert.ToInt16(data.SystemCpuLoad.Value);
            }
            if (data.DroppedFrames.HasValue)
            {
                qualityLog.DroppedFrames = Convert.ToInt16(data.DroppedFrames.Value);
            }
            if (data.RenderedFrames.HasValue)
            {
                qualityLog.RenderedFrames = Convert.ToInt16(data.RenderedFrames.Value);
            }
            if (data.HttpErrorCount.HasValue)
            {
                qualityLog.HttpErrorCount = data.HttpErrorCount.Value;
            }
            if (data.AudioBufferSize.HasValue)
            {
                qualityLog.AudioBufferSize = Convert.ToInt32(data.AudioBufferSize.Value);
            }
            if (data.VideoBufferSize.HasValue)
            {
                qualityLog.VideoBufferSize = Convert.ToInt32(data.VideoBufferSize.Value);
            }
            if (data.PerceivedBandwidth.HasValue)
            {
                qualityLog.PerceivedBandwidth = Convert.ToInt64(data.PerceivedBandwidth.Value);
            }
            if (data.DvrOperationCount.HasValue)
            {
                qualityLog.DVRUseCount = Convert.ToInt32(data.DvrOperationCount.Value);
            }
            if (data.FullScreenChangeCount.HasValue)
            {
                qualityLog.FullScreenChangeCount = data.FullScreenChangeCount.Value;
            }
            if (data.VideoDownloadLatencyMilliseconds.HasValue)
            {
                if (!Double.IsInfinity(data.VideoDownloadLatencyMilliseconds.Value))
                {
                    qualityLog.VideoDownloadLatencyMilliseconds = Convert.ToInt32(data.VideoDownloadLatencyMilliseconds.Value);
                }
            }
            if (data.AudioDownloadLatencyMilliseconds.HasValue)
            {
                if (!Double.IsInfinity(data.AudioDownloadLatencyMilliseconds.Value))
                {
                    qualityLog.AudioDownloadLatencyMilliseconds = Convert.ToInt32(data.AudioDownloadLatencyMilliseconds.Value);
                }
            }

            //qualityLog.Data[VideoLogAttributes.CDNBlocked] = healthMonitor.AnonymousProxy;
        }