iSpyApplication.Controls.VolumeLevel.Record C# (CSharp) Method

Record() private method

private Record ( ) : void
return void
        private void Record()
        {
            string linktofile = "";
            try
            {
                _stopWrite.Reset();

                if (!string.IsNullOrEmpty(Micobject.recorder.trigger))
                {
                    string[] tid = Micobject.recorder.trigger.Split(',');
                    switch (tid[0])
                    {
                        case "1":
                            VolumeLevel vl = MainForm.InstanceReference.GetVolumeLevel(Convert.ToInt32(tid[1]));
                            if (vl != null && !vl.Recording)
                                vl.RecordSwitch(true);
                            break;
                        case "2":
                            CameraWindow c = MainForm.InstanceReference.GetCameraWindow(Convert.ToInt32(tid[1]));
                            if (c != null && !c.Recording)
                                c.RecordSwitch(true);
                            break;
                    }
                }
                var cw = CameraControl;
                //
                if (cw != null)
                {
                    if (cw.AbortedAudio)
                    {
                        Logger.LogErrorToFile(Micobject.name +
                                                ": paired recording aborted as the camera is already recording");
                        ForcedRecording = false;
                        return;
                    }
                }
                try
                {
                    if (cw != null)
                    {
                        cw.ForcedRecording = ForcedRecording;
                        cw.StartSaving();
                        _stopWrite.WaitOne();
                    }
                    else
                    {
                        #region mp3writer

                        DateTime date = DateTime.Now;

                        string filename =
                            $"{date.Year}-{Helper.ZeroPad(date.Month)}-{Helper.ZeroPad(date.Day)}_{Helper.ZeroPad(date.Hour)}-{Helper.ZeroPad(date.Minute)}-{Helper.ZeroPad(date.Second)}";

                        AudioFileName = Micobject.id + "_" + filename;
                        string folder = Dir.Entry + "audio\\" + Micobject.directory + "\\";
                        if (!Directory.Exists(folder))
                            Directory.CreateDirectory(folder);
                        filename = folder + AudioFileName;

                        _writer = new AudioFileWriter();
                        try
                        {
                            Program.FfmpegMutex.WaitOne();
                            _writer.Open(filename + ".mp3", AudioCodec.MP3,
                                AudioSource.RecordingFormat.BitsPerSample*AudioSource.RecordingFormat.SampleRate*
                                AudioSource.RecordingFormat.Channels, AudioSource.RecordingFormat.SampleRate,
                                AudioSource.RecordingFormat.Channels);

                            try
                            {
                                string url = (X509.SslEnabled ? "https" : "http") + "://" + MainForm.IPAddress + "/";
                                linktofile = HttpUtility.UrlEncode(url + "loadclip.mp3?oid=" + Micobject.id + "&ot=1&fn=" + AudioFileName + ".mp3&auth=" + MainForm.Identifier);
                            }
                            catch (Exception ex)
                            {
                                Logger.LogExceptionToFile(ex, "Generating external link to file");
                            }
                            DoAlert("recordingstarted", linktofile);
                        }
                        finally
                        {
                            try
                            {
                                Program.FfmpegMutex.ReleaseMutex();
                            }
                            catch (ObjectDisposedException)
                            {
                                //can happen on shutdown
                            }
                        }

                        double maxlevel = 0;
                        bool first = true;
                        DateTime recordingStart = Helper.Now;

                        try
                        {
                            while (!_stopWrite.WaitOne(5))
                            {
                                Helper.FrameAction fa;
                                while (Buffer.TryDequeue(out fa))
                                {
                                    if (first)
                                    {
                                        recordingStart = fa.TimeStamp;
                                        first = false;
                                    }

                                    if (fa.FrameType == Enums.FrameType.Audio)
                                    {
                                        unsafe
                                        {
                                            fixed (byte* p = fa.Content)
                                            {
                                                _writer.WriteAudio(p, fa.DataLength);
                                            }
                                        }
                                        float d = Levels.Max();
                                        _soundData.Append(string.Format(CultureInfo.InvariantCulture,
                                            "{0:0.000}", d));
                                        _soundData.Append(",");
                                        if (d > maxlevel)
                                            maxlevel = d;
                                    }
                                    fa.Nullify();

                                }
                            }

                            FilesFile ff = _filelist.FirstOrDefault(p => p.Filename.EndsWith(AudioFileName + ".mp3"));
                            bool newfile = false;
                            if (ff == null)
                            {
                                ff = new FilesFile();
                                newfile = true;
                            }

                            string[] fnpath = (filename + ".mp3").Split('\\');
                            string fn = fnpath[fnpath.Length - 1];
                            var fi = new FileInfo(filename + ".mp3");
                            var dSeconds = Convert.ToInt32((Helper.Now - recordingStart).TotalSeconds);

                            ff.CreatedDateTicks = DateTime.Now.Ticks;
                            ff.Filename = fnpath[fnpath.Length - 1];
                            ff.MaxAlarm = maxlevel;
                            ff.SizeBytes = fi.Length;
                            ff.DurationSeconds = dSeconds;
                            ff.IsTimelapse = false;
                            ff.IsMergeFile = false;
                            ff.AlertData = Helper.GetMotionDataPoints(_soundData);
                            _soundData.Clear();
                            ff.TriggerLevel = Micobject.detector.minsensitivity;
                            ff.TriggerLevelMax = Micobject.detector.maxsensitivity;

                            if (newfile)
                            {
                                lock (_lockobject)
                                {
                                    _filelist.Insert(0, ff);
                                }

                                MainForm.MasterFileAdd(new FilePreview(fn, dSeconds, Micobject.name, DateTime.Now.Ticks,
                                    1, Micobject.id, ff.MaxAlarm, false, false));
                                MainForm.NeedsMediaRefresh = Helper.Now;

                            }

                        }
                        catch (Exception ex)
                        {
                            ErrorHandler?.Invoke(ex.Message);
                        }

                        if (_writer != null && _writer.IsOpen)
                        {
                            try
                            {
                                Program.FfmpegMutex.WaitOne();
                                _writer.Dispose();
                            }
                            catch (Exception ex)
                            {
                                ErrorHandler?.Invoke(ex.Message);
                            }
                            finally
                            {
                                try
                                {
                                    Program.FfmpegMutex.ReleaseMutex();
                                }
                                catch (ObjectDisposedException)
                                {
                                    //can happen on shutdown
                                }
                            }
                        }

                        _writer = null;

                        #endregion
                    }

                    UpdateFloorplans(false);
                }
                catch (Exception ex)
                {
                    ErrorHandler?.Invoke(ex.Message);
                }

                if (!string.IsNullOrEmpty(Micobject.recorder.trigger))
                {
                    string[] tid = Micobject.recorder.trigger.Split(',');
                    switch (tid[0])
                    {
                        case "1":
                            VolumeLevel vl = MainForm.InstanceReference.GetVolumeLevel(Convert.ToInt32(tid[1]));
                            vl?.RecordSwitch(false);
                            break;
                        case "2":
                            CameraWindow c = MainForm.InstanceReference.GetCameraWindow(Convert.ToInt32(tid[1]));
                            c?.RecordSwitch(false);
                            break;
                    }
                }

                if (cw == null)
                {
                    Micobject.newrecordingcount++;
                    Notification?.Invoke(this, new NotificationType("NewRecording", Micobject.name, ""));
                    DoAlert("recordingstopped", linktofile);
                }
            }
            catch (Exception ex)
            {
                Logger.LogExceptionToFile(ex);
            }
        }