private static string GetSuggestedStartBleep(string chiefBleepSoundName, string spotterBleepSoundName)
        {
            var resolvedSoundName = chiefBleepSoundName;

            // If there's nothing to do return default value.
            if (!PlaybackModerator.IsFakeBleepInjectionEnabled())
            {
                return(resolvedSoundName);
            }

            // We need to capture the fact that channel was opened as Spotter or Chief, so that
            // subsequent injection is aware of that.
            PlaybackModerator.lastSoundWasSpotter = false;

            if (PlaybackModerator.PrevFirstKeyWasSpotter())
            {
                // Spotter uses opposite bleeps.
                resolvedSoundName = spotterBleepSoundName;
                PlaybackModerator.lastSoundWasSpotter = true;

                PlaybackModerator.Trace("Opening radio channel as Spotter");
            }
            else
            {
                PlaybackModerator.Trace("Opening radio channel as Chief");
            }

            return(resolvedSoundName);
        }
        //public static void PostProcessSound()
        //{ }

        public static bool ShouldPlaySound(SingleSound singleSound, SoundMetadata soundMetadata)
        {
            if (PlaybackModerator.crewChief != null && !PlaybackModerator.crewChief.running)
            {
                PlaybackModerator.Trace(string.Format("Sound {0} rejected because main thread is shutting down", singleSound.fullPath));
                return(false);
            }

            int messageId = soundMetadata == null ? 0 : soundMetadata.messageId;

            if (PlaybackModerator.lastBlockedMessageId == messageId)
            {
                PlaybackModerator.Trace(string.Format("Sound {0} rejected because other members of the same message have been blocked", singleSound.fullPath));
                return(false);
            }

            if (PlaybackModerator.rejectMessagesWhenTalking &&
                soundMetadata.type != SoundType.VOICE_COMMAND_RESPONSE &&
                SpeechRecogniser.waitingForSpeech &&
                MainWindow.voiceOption != MainWindow.VoiceOptionEnum.ALWAYS_ON)
            {
                PlaybackModerator.Trace(string.Format("Sound {0} rejected because we're in the middle of a voice command", singleSound.fullPath));
                if (messageId != 0)
                {
                    PlaybackModerator.lastBlockedMessageId = messageId;
                }

                return(false);
            }

            if (PlaybackModerator.minPriorityForInterrupt != SoundType.OTHER && PlaybackModerator.CanInterrupt(soundMetadata))
            {
                SoundType mostImportantTypeInImmediateQueue = PlaybackModerator.audioPlayer.getPriortyOfFirstWaitingImmediateMessage();
                if (mostImportantTypeInImmediateQueue <= PlaybackModerator.minPriorityForInterrupt)
                {
                    PlaybackModerator.Trace(string.Format("Blocking queued messasge {0} because at least 1 {1} message is waiting",
                                                          singleSound.fullPath, mostImportantTypeInImmediateQueue));

                    PlaybackModerator.Trace("Messages triggering block logic: " + audioPlayer.getMessagesBlocking(minPriorityForInterrupt));

                    if (messageId != 0)
                    {
                        PlaybackModerator.lastBlockedMessageId = messageId;
                    }

                    // ensure the blocking message won't expire
                    var firstWaitingMessage = PlaybackModerator.audioPlayer.getFirstWaitingImmediateMessage(mostImportantTypeInImmediateQueue);
                    if (firstWaitingMessage != null && firstWaitingMessage.expiryTime > 0)
                    {
                        firstWaitingMessage.expiryTime = firstWaitingMessage.expiryTime + 2000;
                    }

                    return(false);
                }
            }
            return(true);
        }
        public static bool MessageCanBeQueued(QueuedMessage queuedMessage, int currentQueueDepth, DateTime now)
        {
            int       priority;
            SoundType type;

            if (queuedMessage.metadata == null)
            {
                PlaybackModerator.Trace("Message " + queuedMessage.messageName + " has no metadata, setting priority and type to default");
                priority = SoundMetadata.DEFAULT_PRIORITY;
                type     = SoundType.REGULAR_MESSAGE;
            }
            else
            {
                priority = queuedMessage.metadata.priority;
                type     = queuedMessage.metadata.type;
            }

            var canPlay = priority >= PlaybackModerator.minPriorityForEachVerbosity[verbosity];

            if (canPlay)
            {
                // not using this Dictionary of played messages so no point in adding data to it. Will leave this code
                // here for now in case i come up with a use-case

                /*
                 * MessageQueueCounter counter;
                 * if (PlaybackModerator.queuedMessageCounters.TryGetValue(queuedMessage.messageName, out counter))
                 * {
                 *  counter.timeQueued = now;
                 *  counter.numberOfTimesQueued = counter.numberOfTimesQueued + 1;
                 * }
                 * else
                 * {
                 *  PlaybackModerator.queuedMessageCounters.Add(queuedMessage.messageName, new MessageQueueCounter(now));
                 * }
                 */
            }
            else
            {
                PlaybackModerator.Trace(string.Format("Message {0} hasn't been queued because its priority is {1} and our verbosity is currently {2}", queuedMessage.messageName, priority, verbosity));
            }

            return(canPlay);
        }
        public static string GetSuggestedBleepEnd()
        {
            var resolvedSoundName = "end_bleep";

            // If there's nothing to do return default value.
            if (!PlaybackModerator.IsFakeBleepInjectionEnabled())
            {
                return(resolvedSoundName);
            }

            if (PlaybackModerator.PrevLastKeyWasSpotter())
            {
                // Spotter uses opposite bleeps.
                resolvedSoundName = "alternate_end_bleep";

                PlaybackModerator.Trace("Closing radio channel as Spotter");

                if (PlaybackModerator.lastSoundPreProcessed != null &&
                    !PlaybackModerator.lastSoundPreProcessed.isSpotter)
                {
                    PlaybackModerator.Trace(string.Format(
                                                "WARNING Last key and last sound pre-processed do not agree on role: {0} vs {1} ",
                                                PlaybackModerator.lastSoundPreProcessed.fullPath, PlaybackModerator.prevLastKey));
                }
            }
            else
            {
                PlaybackModerator.Trace("Closing radio channel as Chief");

                if (PlaybackModerator.lastSoundPreProcessed != null &&
                    PlaybackModerator.lastSoundPreProcessed.isSpotter)
                {
                    PlaybackModerator.Trace(string.Format(
                                                "WARNING Last key and last sound pre-processed do not agree on role: {0} vs {1} ",
                                                PlaybackModerator.lastSoundPreProcessed.fullPath, PlaybackModerator.lastSoundPreProcessed.fullPath));
                }
            }

            return(resolvedSoundName);
        }
        private static void InjectBeepOutIn(SingleSound sound, SoundMetadata soundMetadata)
        {
            Debug.Assert(PlaybackModerator.audioPlayer != null, "audioPlayer is not set.");

            // Only consider injection is preference is set and Spotter and Chief are different personas.
            if (!PlaybackModerator.IsFakeBleepInjectionEnabled())
            {
                return;
            }

            // Skip bleep sounds.
            if (sound.isBleep)
            {
                return;
            }

            // Inject bleep out/in if needed.
            var isSpotterSound = sound.isSpotter;  // Alternatively, we could assign a role to each queued sound.  We'll need this if we get more "personas" than Chief and Spotter.

            if (((!PlaybackModerator.lastSoundWasSpotter && isSpotterSound) || // If we are flipping from the Chief to Spotter
                 (PlaybackModerator.lastSoundWasSpotter && !isSpotterSound)) && // Or from the Spotter to Chief
                PlaybackModerator.audioPlayer.isChannelOpen() &&  // And, channel is still open
                (PlaybackModerator.lastSoundPreProcessed == null || !PlaybackModerator.lastSoundPreProcessed.isBleep))      // and the last sound wasn't also a beep (to stop the spotter kicking off with a double-beep)
            {
                // Ok, so idea here is that Chief and Spotter have different bleeps.  So we use opposing sets.
                string keyBleepOut = null;
                string keyBleepIn  = null;

                string traceMsgPostfix = null;
                if (isSpotterSound)
                {
                    // Spotter uses opposite blips.
                    keyBleepOut = "end_bleep";  // Chief uses regular bleeps.
                    keyBleepIn  = "alternate_short_start_bleep";

                    traceMsgPostfix = "Spotter interrupted Chief.";
                }
                else  // Chief comes in.
                {
                    keyBleepOut = "alternate_end_bleep";  // Spotter uses alternate bleeps
                    keyBleepIn  = "short_start_bleep";

                    traceMsgPostfix = "Chief interrupted Spotter.";
                }

                PlaybackModerator.Trace(string.Format("Injecting: {0} and {1} messages. {2}", keyBleepOut, keyBleepIn, traceMsgPostfix));

                // insert bleep out/in
                if (PlaybackModerator.insertBeepOutBetweenSpotterAndChief)
                {
                    PlaybackModerator.audioPlayer.getSoundCache().Play(keyBleepOut, soundMetadata);
                }

                // would be nice to have some slight random silence here
                if (PlaybackModerator.insertBeepInBetweenSpotterAndChief)
                {
                    PlaybackModerator.audioPlayer.getSoundCache().Play(keyBleepIn, soundMetadata);
                }
            }

            PlaybackModerator.lastSoundWasSpotter = isSpotterSound;
        }