private bool RxOn()
{
//Debug.Assert(_RxPorts.Count == 0);
//Debug.Assert(_AudioVia == RdRxAudioVia.NoAudio);
SetAudioVia(NextRxAudioVia());
_RealAudioVia = AudioVia; // RdRxAudioVia.Speaker;
if (AudioVia == RdRxAudioVia.NoAudio)
{
return(false);
}
General.SafeLaunchEvent(RxAlreadyAssigned, this);
foreach (Rs <RdSrvRxRs> rxRs in _AssociateRxRs)
{
if (rxRs.IsValid /*&& _RscSite.ContainsKey(rxRs.Id) && _RscSite[rxRs.Id] == Alias*/)
{
if (!_RxPorts.ContainsKey(rxRs.Id.ToUpper()))
{
CreateRxAudio(rxRs, rxRs.Id.ToUpper());
}
}
}
return(true);
}
public void RdConfirmRxAudio(int id, RdRxAudioVia via)
{
RdDst dst = _StateManager.Radio[id];
Debug.Assert((_StateManager.Radio.Rtx == 0) || !dst.Tx || ((dst.RtxGroup != 0) && (dst.RtxGroup != _StateManager.Radio.Rtx)));
_EngineCmdManager.SetRdAudio(id, via);
}
public void Reset(RdInfo dst)
{
if (dst.Dst == "")
{
Reset();
}
else
{
_Frecuency = dst.Dst;
_Alias = dst.Alias;
_TempAlias = string.Empty;
_Ptt = dst.Ptt;
_Squelch = dst.Squelch;
_Tx = dst.Tx;
_Rx = dst.Rx || _Tx;
_AudioVia = _Rx ? dst.AudioVia : RdRxAudioVia.NoAudio;
_Monitoring = dst.Monitoring;// && !Unavailable;
_RtxGroup = _TempRtxGroup = dst.RtxGroup;
_TipoFrecuencia = dst.TipoFrecuencia;
_State = dst.Estado;
_qidxResource = _qidxMethod = string.Empty;
_qidxValue = 0;
_RxOnly = dst.RxOnly;
/** 20180321. AGL. ALIAS a mostrar en la tecla... */
if (Properties.Settings.Default.RadioAlias == true)
{
_KeyAlias = dst.KeyAlias == dst.Dst ? "" : dst.KeyAlias;
}
else
{
_KeyAlias = (_TempAlias != string.Empty && _TempAlias != _Alias) ? _TempAlias : _Alias;
}
/** */
if (!Restored && Unavailable && (dst.Ptt != PttState.Unavailable || dst.Squelch != SquelchState.Unavailable))
{
_Restored = true;
}
else
{
_Restored = false;
}
Debug.Assert(!_Rx || (_AudioVia != RdRxAudioVia.NoAudio));
Debug.Assert(!_Tx || Rx);
if ((_Squelch == SquelchState.SquelchPortAndMod) && (_Ptt == PttState.PttOnlyPort))
{
_Ptt = PttState.PttPortAndMod;
}
else if ((_Squelch == SquelchState.SquelchOnlyPort) && (_Ptt == PttState.PttPortAndMod))
{
_Ptt = PttState.PttOnlyPort;
}
//_PttSrcId = dst.PttSrcId;
}
}
/// <summary>
/// Redirige al audio hacia el proximo destino según rotación
/// </summary>
/// <param name="audioVia"></param>
public void SetNextAudioVia()
{
RdRxAudioVia newAudio = NextRxAudioVia();
if (newAudio == RdRxAudioVia.NoAudio)
{
SetRx(false);
}
else
{
SetAudioVia(newAudio);
}
}
public void Reset(RdAsignState st)
{
_Tx = st.Tx;
_Rx = st.Rx;
_AudioVia = st.AudioVia;
Debug.Assert(!_Rx || (_AudioVia != RdRxAudioVia.NoAudio));
Debug.Assert(!_Tx || Rx);
if (!_Tx)
{
_RtxGroup = Math.Min(_RtxGroup, 0);
_TempRtxGroup = _RtxGroup;
}
}
public RdInfo(string dst, string alias, bool tx, bool rx, PttState ptt, SquelchState squelch,
RdRxAudioVia audioVia, int rtxGroup, TipoFrecuencia_t tipoFrecuencia, bool monitoring, FrequencyState estado, bool rxOnly)
{
Dst = dst;
Alias = alias;
Tx = tx;
Rx = rx;
Ptt = ptt;
Squelch = squelch;
AudioVia = audioVia;
RtxGroup = rtxGroup;
TipoFrecuencia = tipoFrecuencia;
Monitoring = monitoring;
Estado = estado;
RxOnly = rxOnly;
}
public void Reset(RdState st)
{
if (Unavailable && (st.Ptt != PttState.Unavailable || st.Squelch != SquelchState.Unavailable))
{
_Restored = true;
}
else
{
_Restored = false;
}
_Ptt = st.Ptt;
_Squelch = st.Squelch;
_Tx = st.Tx;
_Rx = st.Rx || _Tx; // || _Monitoring || _Tx;
_AudioVia = _Rx ? st.AudioVia : RdRxAudioVia.NoAudio; // !_Monitoring ? st.AudioVia : RdRxAudioVia.Speaker;
if (_RtxGroup != _TempRtxGroup)
{
_RtxGroup = st.RtxGroup;
}
else
{
_RtxGroup = _TempRtxGroup = st.RtxGroup;
}
//_RtxGroup = st.RtxGroup;
Debug.Assert(!_Rx || (_AudioVia != RdRxAudioVia.NoAudio));
Debug.Assert(!_Tx || Rx);
if ((_Squelch == SquelchState.SquelchPortAndMod) && (_Ptt == PttState.PttOnlyPort))
{
_Ptt = PttState.PttPortAndMod;
}
else if ((_Squelch == SquelchState.SquelchOnlyPort) && (_Ptt == PttState.PttPortAndMod))
{
_Ptt = PttState.PttOnlyPort;
}
// BSS Information
_qidxMethod = st.QidxMethod;
_qidxResource = st.QidxResource;
_qidxValue = st.QidxValue;
_State = st.State;
_PttSrcId = st.PttSrcId;
}
public RdState(bool tx, bool rx, string pttSrcId, PttState ptt, SquelchState squelch, RdRxAudioVia audioVia, int rtxGroup, FrequencyState state,
string qidxMethod, uint qidxValue, string qidxResource)
{
Tx = tx;
Rx = rx;
Ptt = ptt;
Squelch = squelch;
AudioVia = audioVia;
RtxGroup = rtxGroup;
State = state;
// BSS Information
QidxMethod = qidxMethod;
QidxValue = qidxValue;
QidxResource = qidxResource;
PttSrcId = pttSrcId;
}
private void RxOff()
{
if (Rx)
{
foreach (int port in _RxPorts.Values)
{
Top.Mixer.Unlink(port);
SipAgent.DestroyRdRxPort(port);
_Logger.Debug("*** RxOff. Llamando a DestroyRdRxPort({0}) {1}", port, Literal);
}
_RxPorts.Clear();
_AudioVia = RdRxAudioVia.NoAudio;
_RealAudioVia = RdRxAudioVia.NoAudio;
_Tx = AssignState.Idle;
_RtxGroup = Math.Min(_RtxGroup, 0);
}
}
public void ResetToIdle()
{
_Tx = false;
_Rx = false;
_Ptt = PttState.NoPtt;
_Squelch = SquelchState.NoSquelch;
_AudioVia = RdRxAudioVia.NoAudio;
_RtxGroup = _TempRtxGroup = 0;
_Monitoring = false;
_Restored = true;
_TipoFrecuencia = TipoFrecuencia_t.Basica;
_qidxResource = _qidxMethod = string.Empty;
_qidxValue = 0;
_State = FrequencyState.NotAvailable;
_RxOnly = false;
/** 20190205 */
_PttSrcId = string.Empty;
}
/// <summary>
/// Redirige al audio hacia el destino indicado (altavoz o auricular) con las siguientes condiciones:
/// 1-Si no hay PTT, se conecta el audio siempre.
/// 2-Si hay PTT propio no se hace nada, no está permitido cambiar la salida del audio.
/// 3-Si hay PTT que procede de una RTX de otro SQ y estoy en el puesto propietario del grupo y el SQ es propio,
/// no conecto mi audio porque se debe escuchar el que se está retransmitiendo.
/// </summary>
/// <param name="audioVia"></param>
public void SetAudioVia(RdRxAudioVia audioVia)
{
if (/*Rx && */ (_AudioVia != audioVia) &&
((audioVia == RdRxAudioVia.Speaker && Top.Hw.RdSpeaker) ||
(audioVia == RdRxAudioVia.HfSpeaker && Top.Hw.HfSpeaker) ||
(audioVia == RdRxAudioVia.HeadPhones &&
(Top.Hw.InstructorJack || Top.Hw.AlumnJack) && !Top.Mixer.ModoSoloAltavoces)))
{
if (InhiboMiAudio(_Ptt, _AssociateFrRs.Info) == false)
{
foreach (int port in _RxPorts.Values)
{
Top.Mixer.Unlink(port);
MixerDev dev = (audioVia == RdRxAudioVia.HeadPhones ? MixerDev.MhpRd : (audioVia == RdRxAudioVia.HfSpeaker ? MixerDev.SpkHf : MixerDev.SpkRd));
Top.Mixer.Link(port, dev, MixerDir.Send, Mixer.RD_PRIORITY, FuentesGlp.RxRadio);
}
}
AudioVia = audioVia;
}
}
public bool InSpeaker(RdRxAudioVia speaker)
{
bool ret = false;
if (AudioVia == speaker)
{
ret = true;
}
else if (AudioVia == RdRxAudioVia.HeadPhones)
{
MixerDev dev = (speaker == RdRxAudioVia.HfSpeaker) ? dev = MixerDev.SpkHf: MixerDev.SpkRd;
foreach (int port in _RxPorts.Values)
{
if (Top.Mixer.MatchActiveLink(dev, port))
{
ret = true;
break;
}
}
}
return(ret);
}
/// <summary>
/// Funcion que calcula el siguiente estado de audio para RX en la rotación,
/// teniendo en cuenta la configuración y el estado de los altavoces
/// y el estado del RdDst.Tx
/// </summary>
/// <returns>audio via</returns>
private RdRxAudioVia NextRxAudioVia()
{
RdRxAudioVia audioViaKO = RdRxAudioVia.NoAudio;
switch (AudioVia)
{
case RdRxAudioVia.NoAudio:
if (Top.Hw.RdSpeaker)
{
return(RdRxAudioVia.Speaker);
}
else if (Top.Rd.HFSpeakerAvailable() &&
((TipoFrecuencia == TipoFrecuencia_t.HF) || Top.Rd.DoubleRadioSpeaker))
{
return(RdRxAudioVia.HfSpeaker);
}
else if (!Top.Mixer.ModoSoloAltavoces)
{
return(RdRxAudioVia.HeadPhones);
}
audioViaKO = RdRxAudioVia.Speaker;
break;
case RdRxAudioVia.Speaker:
if (Top.Rd.HFSpeakerAvailable() &&
((TipoFrecuencia == TipoFrecuencia_t.HF) || Top.Rd.DoubleRadioSpeaker))
{
return(RdRxAudioVia.HfSpeaker);
}
else if (Top.Mixer.ModoSoloAltavoces)
{
if (!Tx)
{
return(RdRxAudioVia.NoAudio);
}
}
else
{
return(RdRxAudioVia.HeadPhones);
}
if (!Top.Mixer.ModoSoloAltavoces)
{
audioViaKO = RdRxAudioVia.HeadPhones;
}
else
{
// No saca ventana de via no disponible
return(RdRxAudioVia.Speaker);
}
break;
case RdRxAudioVia.HfSpeaker:
if (Top.Mixer.ModoSoloAltavoces)
{
if (!Tx)
{
return(RdRxAudioVia.NoAudio);
}
else if (Top.Hw.RdSpeaker)
{
return(RdRxAudioVia.Speaker);
}
}
else
{
return(RdRxAudioVia.HeadPhones);
}
if (!Top.Mixer.ModoSoloAltavoces)
{
audioViaKO = RdRxAudioVia.HeadPhones;
}
else
{
// No saca ventana de via no disponible
return(RdRxAudioVia.HfSpeaker);
}
audioViaKO = RdRxAudioVia.HeadPhones;
break;
default: // RdRxAudioVia.HeadPhones
if (!Tx)
{
return(RdRxAudioVia.NoAudio);
}
else if (Top.Hw.RdSpeaker)
{
return(RdRxAudioVia.Speaker);
}
else if (Top.Rd.HFSpeakerAvailable() &&
((TipoFrecuencia == TipoFrecuencia_t.HF) || Top.Rd.DoubleRadioSpeaker))
{
return(RdRxAudioVia.HfSpeaker);
}
audioViaKO = RdRxAudioVia.Speaker;
break;
}
General.SafeLaunchEvent(AudioViaNotAvailable, this, audioViaKO);
return(AudioVia);
}
public void SetRdAudio(int id, RdRxAudioVia audio)
{
_Comm.Send(new byte[] { (byte)OpeEventType.Radio, (byte)RdCmdType.RxClick, (byte)(id + 1) });
_Logger.Debug("(Tx) Radio: [Id={0}] [AudioVia={1}]", id, audio);
}
public RdAsignState(bool tx, bool rx, RdRxAudioVia audio)
{
Tx = tx;
Rx = rx;
AudioVia = audio;
}
