| /* |
| * Copyright (c) 2011 The WebRTC project authors. All Rights Reserved. |
| * |
| * Use of this source code is governed by a BSD-style license |
| * that can be found in the LICENSE file in the root of the source |
| * tree. An additional intellectual property rights grant can be found |
| * in the file PATENTS. All contributing project authors may |
| * be found in the AUTHORS file in the root of the source tree. |
| */ |
| |
| #include <math.h> |
| #include "stdafx.h" |
| #include "WinTest.h" |
| #include "WinTestDlg.h" |
| |
| #ifdef _DEBUG |
| #define new DEBUG_NEW |
| #endif |
| |
| using namespace webrtc; |
| |
| unsigned char key[30] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; |
| |
| // Hack to convert char to TCHAR, using two buffers to be able to |
| // call twice in the same statement |
| TCHAR convertTemp1[256] = {0}; |
| TCHAR convertTemp2[256] = {0}; |
| bool convertBufferSwitch(false); |
| TCHAR* CharToTchar(const char* str, int len) |
| { |
| #ifdef _UNICODE |
| TCHAR* temp = convertBufferSwitch ? convertTemp1 : convertTemp2; |
| convertBufferSwitch = !convertBufferSwitch; |
| memset(temp, 0, sizeof(convertTemp1)); |
| MultiByteToWideChar(CP_UTF8, 0, str, len, temp, 256); |
| return temp; |
| #else |
| return str; |
| #endif |
| } |
| |
| // Hack to convert TCHAR to char |
| char convertTemp3[256] = {0}; |
| char* TcharToChar(TCHAR* str, int len) |
| { |
| #ifdef _UNICODE |
| memset(convertTemp3, 0, sizeof(convertTemp3)); |
| WideCharToMultiByte(CP_UTF8, 0, str, len, convertTemp3, 256, 0, 0); |
| return convertTemp3; |
| #else |
| return str; |
| #endif |
| } |
| |
| // ---------------------------------------------------------------------------- |
| // VoEConnectionObserver |
| // ---------------------------------------------------------------------------- |
| |
| class ConnectionObserver : public VoEConnectionObserver |
| { |
| public: |
| ConnectionObserver(); |
| virtual void OnPeriodicDeadOrAlive(const int channel, const bool alive); |
| }; |
| |
| ConnectionObserver::ConnectionObserver() |
| { |
| } |
| |
| void ConnectionObserver::OnPeriodicDeadOrAlive(const int channel, const bool alive) |
| { |
| CString str; |
| str.Format(_T("OnPeriodicDeadOrAlive(channel=%d) => alive=%d"), channel, alive); |
| OutputDebugString(str); |
| } |
| |
| // ---------------------------------------------------------------------------- |
| // VoiceEngineObserver |
| // ---------------------------------------------------------------------------- |
| |
| void CWinTestDlg::CallbackOnError(const int channel, const int errCode) |
| { |
| _nErrorCallbacks++; |
| |
| CString str; |
| str.Format(_T("[#%d] CallbackOnError(channel=%d) => errCode = %d"), _nErrorCallbacks, channel, errCode); |
| if (errCode == VE_RECEIVE_PACKET_TIMEOUT) |
| { |
| str += _T(" <=> VE_RECEIVE_PACKET_TIMEOUT"); |
| } |
| else if (errCode == VE_PACKET_RECEIPT_RESTARTED) |
| { |
| str += _T(" <=> VE_PACKET_RECEIPT_RESTARTED"); |
| } |
| else if (errCode == VE_RUNTIME_PLAY_WARNING) |
| { |
| str += _T(" <=> VE_RUNTIME_PLAY_WARNING"); |
| } |
| else if (errCode == VE_RUNTIME_REC_WARNING) |
| { |
| str += _T(" <=> VE_RUNTIME_REC_WARNING"); |
| } |
| else if (errCode == VE_RUNTIME_PLAY_ERROR) |
| { |
| str += _T(" <=> VE_RUNTIME_PLAY_ERROR"); |
| } |
| else if (errCode == VE_RUNTIME_REC_ERROR) |
| { |
| str += _T(" <=> VE_RUNTIME_REC_ERROR"); |
| } |
| else if (errCode == VE_SATURATION_WARNING) |
| { |
| str += _T(" <=> VE_SATURATION_WARNING"); |
| } |
| else if (errCode == VE_TYPING_NOISE_WARNING) |
| { |
| str += _T(" <=> VE_TYPING_NOISE_WARNING"); |
| } |
| else if (errCode == VE_REC_DEVICE_REMOVED) |
| { |
| str += _T(" <=> VE_REC_DEVICE_REMOVED"); |
| } |
| // AfxMessageBox((LPCTSTR)str, MB_OK); |
| SetDlgItemText(IDC_EDIT_ERROR_CALLBACK, (LPCTSTR)str); |
| } |
| |
| // ---------------------------------------------------------------------------- |
| // VoERTPObserver |
| // ---------------------------------------------------------------------------- |
| |
| void CWinTestDlg::OnIncomingCSRCChanged(const int channel, const unsigned int CSRC, const bool added) |
| { |
| CString str; |
| str.Format(_T("OnIncomingCSRCChanged(channel=%d) => CSRC=%u, added=%d"), channel, CSRC, added); |
| SetDlgItemText(IDC_EDIT_ERROR_CALLBACK, (LPCTSTR)str); |
| } |
| |
| void CWinTestDlg::OnIncomingSSRCChanged(const int channel, const unsigned int SSRC) |
| { |
| CString str; |
| str.Format(_T("OnIncomingSSRCChanged(channel=%d) => SSRC=%u"), channel, SSRC); |
| SetDlgItemText(IDC_EDIT_ERROR_CALLBACK, (LPCTSTR)str); |
| } |
| |
| // ---------------------------------------------------------------------------- |
| // Transport |
| // ---------------------------------------------------------------------------- |
| |
| class MyTransport : public Transport |
| { |
| public: |
| MyTransport(VoENetwork* veNetwork); |
| virtual int SendPacket(int channel, const void *data, int len); |
| virtual int SendRTCPPacket(int channel, const void *data, int len); |
| private: |
| VoENetwork* _veNetworkPtr; |
| }; |
| |
| MyTransport::MyTransport(VoENetwork* veNetwork) : |
| _veNetworkPtr(veNetwork) |
| { |
| } |
| |
| int |
| MyTransport::SendPacket(int channel, const void *data, int len) |
| { |
| _veNetworkPtr->ReceivedRTPPacket(channel, data, len); |
| return len; |
| } |
| |
| int |
| MyTransport::SendRTCPPacket(int channel, const void *data, int len) |
| { |
| _veNetworkPtr->ReceivedRTCPPacket(channel, data, len); |
| return len; |
| } |
| |
| // ---------------------------------------------------------------------------- |
| // VoEMediaProcess |
| // ---------------------------------------------------------------------------- |
| |
| class MediaProcessImpl : public VoEMediaProcess |
| { |
| public: |
| MediaProcessImpl(); |
| virtual void Process(const int channel, |
| const ProcessingTypes type, |
| WebRtc_Word16 audio_10ms[], |
| const int length, |
| const int samplingFreqHz, |
| const bool stereo); |
| }; |
| |
| MediaProcessImpl::MediaProcessImpl() |
| { |
| } |
| |
| void MediaProcessImpl::Process(const int channel, |
| const ProcessingTypes type, |
| WebRtc_Word16 audio_10ms[], |
| const int length, |
| const int samplingFreqHz, |
| const bool stereo) |
| { |
| int x = rand() % 100; |
| |
| for (int i = 0; i < length; i++) |
| { |
| if (channel == -1) |
| { |
| if (type == kPlaybackAllChannelsMixed) |
| { |
| // playout: scale up |
| if (!stereo) |
| { |
| audio_10ms[i] = (audio_10ms[i] << 2); |
| } |
| else |
| { |
| audio_10ms[2*i] = (audio_10ms[2*i] << 2); |
| audio_10ms[2*i+1] = (audio_10ms[2*i+1] << 2); |
| } |
| } |
| else |
| { |
| // recording: emulate packet loss by "dropping" 10% of the packets |
| if (x >= 0 && x < 10) |
| { |
| if (!stereo) |
| { |
| audio_10ms[i] = 0; |
| } |
| else |
| { |
| audio_10ms[2*i] = 0; |
| audio_10ms[2*i+1] = 0; |
| } |
| } |
| } |
| } |
| else |
| { |
| if (type == kPlaybackPerChannel) |
| { |
| // playout: mute |
| if (!stereo) |
| { |
| audio_10ms[i] = 0; |
| } |
| else |
| { |
| audio_10ms[2*i] = 0; |
| audio_10ms[2*i+1] = 0; |
| } |
| } |
| else |
| { |
| // recording: emulate packet loss by "dropping" 50% of the packets |
| if (x >= 0 && x < 50) |
| { |
| if (!stereo) |
| { |
| audio_10ms[i] = 0; |
| } |
| else |
| { |
| audio_10ms[2*i] = 0; |
| audio_10ms[2*i+1] = 0; |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| // ---------------------------------------------------------------------------- |
| // Encryptionen |
| // ---------------------------------------------------------------------------- |
| |
| class MyEncryption : public Encryption |
| { |
| public: |
| void encrypt(int channel_no, unsigned char * in_data, unsigned char * out_data, int bytes_in, int* bytes_out); |
| void decrypt(int channel_no, unsigned char * in_data, unsigned char * out_data, int bytes_in, int* bytes_out); |
| void encrypt_rtcp(int channel_no, unsigned char * in_data, unsigned char * out_data, int bytes_in, int* bytes_out); |
| void decrypt_rtcp(int channel_no, unsigned char * in_data, unsigned char * out_data, int bytes_in, int* bytes_out); |
| }; |
| |
| void MyEncryption::encrypt(int channel_no, unsigned char * in_data, unsigned char * out_data, int bytes_in, int* bytes_out) |
| { |
| // --- Stereo emulation (sample based, 2 bytes per sample) |
| |
| const int nBytesPayload = bytes_in-12; |
| |
| // RTP header (first 12 bytes) |
| memcpy(out_data, in_data, 12); |
| |
| // skip RTP header |
| short* ptrIn = (short*) &in_data[12]; |
| short* ptrOut = (short*) &out_data[12]; |
| |
| // network byte order |
| for (int i = 0; i < nBytesPayload/2; i++) |
| { |
| // produce two output samples for each input sample |
| *ptrOut++ = *ptrIn; // left sample |
| *ptrOut++ = *ptrIn; // right sample |
| ptrIn++; |
| } |
| |
| *bytes_out = 12 + 2*nBytesPayload; |
| |
| /* |
| for(int i = 0; i < bytes_in; i++) |
| out_data[i] =~ in_data[i]; |
| *bytes_out = bytes_in; |
| */ |
| } |
| |
| void MyEncryption::decrypt(int channel_no, unsigned char * in_data, unsigned char * out_data, int bytes_in, int* bytes_out) |
| { |
| // Do nothing (<=> memcpy) |
| for(int i = 0; i < bytes_in; i++) |
| out_data[i] = in_data[i]; |
| *bytes_out = bytes_in; |
| } |
| |
| void MyEncryption::encrypt_rtcp(int channel_no, unsigned char * in_data, unsigned char * out_data, int bytes_in, int* bytes_out) |
| { |
| for(int i = 0; i < bytes_in; i++) |
| out_data[i] =~ in_data[i]; |
| *bytes_out = bytes_in; |
| } |
| |
| void MyEncryption::decrypt_rtcp(int channel_no, unsigned char * in_data, unsigned char * out_data, int bytes_in, int* bytes_out) |
| { |
| for(int i = 0; i < bytes_in; i++) |
| out_data[i] =~ in_data[i]; |
| *bytes_out = bytes_in; |
| } |
| |
| // ---------------------------------------------------------------------------- |
| // TelephoneEventObserver |
| // ---------------------------------------------------------------------------- |
| |
| class TelephoneEventObserver: public VoETelephoneEventObserver |
| { |
| public: |
| TelephoneEventObserver(CWnd* editControlOut, CWnd* editControlIn); |
| virtual void OnReceivedTelephoneEventInband(int channel, int eventCode, |
| bool endOfEvent); |
| virtual void OnReceivedTelephoneEventOutOfBand(int channel, int eventCode, |
| bool endOfEvent); |
| private: |
| CWnd* _editControlOutPtr; |
| CWnd* _editControlInPtr; |
| }; |
| |
| TelephoneEventObserver::TelephoneEventObserver(CWnd* editControlOut, CWnd* editControlIn) : |
| _editControlOutPtr(editControlOut), |
| _editControlInPtr(editControlIn) |
| { |
| } |
| |
| void TelephoneEventObserver::OnReceivedTelephoneEventInband(int channel, |
| int eventCode, |
| bool endOfEvent) |
| { |
| CString msg; |
| if (endOfEvent) |
| { |
| msg.AppendFormat(_T("%d [END]"), eventCode); |
| _editControlInPtr->SetWindowText((LPCTSTR)msg); |
| } |
| else |
| { |
| msg.AppendFormat(_T("%d [START]"), eventCode); |
| _editControlInPtr->SetWindowText((LPCTSTR)msg); |
| } |
| } |
| |
| void TelephoneEventObserver::OnReceivedTelephoneEventOutOfBand(int channel, |
| int eventCode, |
| bool endOfEvent) |
| { |
| CString msg; |
| if (endOfEvent) |
| { |
| msg.AppendFormat(_T("%d [END]"), eventCode); |
| _editControlOutPtr->SetWindowText((LPCTSTR)msg); |
| } |
| else |
| { |
| msg.AppendFormat(_T("%d [START]"), eventCode); |
| _editControlOutPtr->SetWindowText((LPCTSTR)msg); |
| } |
| } |
| |
| // ---------------------------------------------------------------------------- |
| // RxVadCallback |
| // ---------------------------------------------------------------------------- |
| |
| class RxCallback : public VoERxVadCallback |
| { |
| public: |
| RxCallback() : _vadDecision(-1) {}; |
| |
| virtual void OnRxVad(int , int vadDecision) |
| { |
| _vadDecision = vadDecision; |
| } |
| |
| int _vadDecision; |
| }; |
| |
| // ---------------------------------------------------------------------------- |
| // CAboutDlg dialog |
| // ---------------------------------------------------------------------------- |
| |
| class CAboutDlg : public CDialog |
| { |
| public: |
| CAboutDlg(); |
| |
| // Dialog Data |
| enum { IDD = IDD_ABOUTBOX }; |
| |
| protected: |
| virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support |
| |
| // Implementation |
| protected: |
| DECLARE_MESSAGE_MAP() |
| }; |
| |
| CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD) |
| { |
| } |
| |
| void CAboutDlg::DoDataExchange(CDataExchange* pDX) |
| { |
| CDialog::DoDataExchange(pDX); |
| } |
| |
| BEGIN_MESSAGE_MAP(CAboutDlg, CDialog) |
| END_MESSAGE_MAP() |
| |
| // ---------------------------------------------------------------------------- |
| // CTelephonyEvent dialog |
| // ---------------------------------------------------------------------------- |
| |
| class CTelephonyEvent : public CDialog |
| { |
| DECLARE_DYNAMIC(CTelephonyEvent) |
| |
| public: |
| CTelephonyEvent(VoiceEngine* voiceEngine, int channel, CDialog* pParentDialog, CWnd* pParent = NULL); // standard constructor |
| virtual ~CTelephonyEvent(); |
| |
| // Dialog Data |
| enum { IDD = IDD_DTMF_DIALOG }; |
| |
| protected: |
| virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support |
| virtual BOOL OnInitDialog(); |
| |
| DECLARE_MESSAGE_MAP() |
| public: |
| afx_msg void OnBnClickedButton1(); |
| afx_msg void OnBnClickedButton2(); |
| afx_msg void OnBnClickedButton3(); |
| afx_msg void OnBnClickedButton4(); |
| afx_msg void OnBnClickedButton5(); |
| afx_msg void OnBnClickedButton6(); |
| afx_msg void OnBnClickedButton7(); |
| afx_msg void OnBnClickedButton8(); |
| afx_msg void OnBnClickedButton9(); |
| afx_msg void OnBnClickedButton10(); |
| afx_msg void OnBnClickedButton11(); |
| afx_msg void OnBnClickedButton12(); |
| afx_msg void OnBnClickedButtonA(); |
| afx_msg void OnBnClickedButtonB(); |
| afx_msg void OnBnClickedButtonC(); |
| afx_msg void OnBnClickedButtonD(); |
| afx_msg void OnBnClickedCheckDtmfPlayoutRx(); |
| afx_msg void OnBnClickedCheckDtmfPlayTone(); |
| afx_msg void OnBnClickedCheckStartStopMode(); |
| afx_msg void OnBnClickedCheckEventInband(); |
| afx_msg void OnBnClickedCheckDtmfFeedback(); |
| afx_msg void OnBnClickedCheckDirectFeedback(); |
| afx_msg void OnBnClickedRadioSingle(); |
| afx_msg void OnBnClickedRadioMulti(); |
| afx_msg void OnBnClickedRadioStartStop(); |
| afx_msg void OnBnClickedButtonSetRxTelephonePt(); |
| afx_msg void OnBnClickedButtonSetTxTelephonePt(); |
| afx_msg void OnBnClickedButtonSendTelephoneEvent(); |
| afx_msg void OnBnClickedCheckDetectInband(); |
| afx_msg void OnBnClickedCheckDetectOutOfBand(); |
| afx_msg void OnBnClickedCheckEventDetection(); |
| |
| private: |
| void SendTelephoneEvent(unsigned char eventCode); |
| |
| private: |
| VoiceEngine* _vePtr; |
| VoEBase* _veBasePtr; |
| VoEDtmf* _veDTMFPtr; |
| VoECodec* _veCodecPtr; |
| int _channel; |
| CString _strMsg; |
| CDialog* _parentDialogPtr; |
| TelephoneEventObserver* _telephoneEventObserverPtr; |
| bool _PlayDtmfToneLocally; |
| bool _modeStartStop; |
| bool _modeSingle; |
| bool _modeSequence; |
| bool _playingDTMFTone; |
| bool _outOfBandEventDetection; |
| bool _inbandEventDetection; |
| }; |
| |
| IMPLEMENT_DYNAMIC(CTelephonyEvent, CDialog) |
| |
| CTelephonyEvent::CTelephonyEvent(VoiceEngine* voiceEngine, |
| int channel, |
| CDialog* pParentDialog, |
| CWnd* pParent /*=NULL*/) |
| : _vePtr(voiceEngine), |
| _channel(channel), |
| _PlayDtmfToneLocally(false), |
| _modeStartStop(false), |
| _modeSingle(true), |
| _modeSequence(false), |
| _playingDTMFTone(false), |
| _outOfBandEventDetection(true), |
| _inbandEventDetection(false), |
| _parentDialogPtr(pParentDialog), |
| _telephoneEventObserverPtr(NULL), |
| CDialog(CTelephonyEvent::IDD, pParent) |
| { |
| _veBasePtr = VoEBase::GetInterface(_vePtr); |
| _veDTMFPtr = VoEDtmf::GetInterface(_vePtr); |
| _veCodecPtr = VoECodec::GetInterface(_vePtr); |
| } |
| |
| CTelephonyEvent::~CTelephonyEvent() |
| { |
| _veDTMFPtr->Release(); |
| _veCodecPtr->Release(); |
| _veBasePtr->Release(); |
| |
| if (_telephoneEventObserverPtr) |
| { |
| _veDTMFPtr->DeRegisterTelephoneEventDetection(_channel); |
| delete _telephoneEventObserverPtr; |
| _telephoneEventObserverPtr = NULL; |
| } |
| } |
| |
| void CTelephonyEvent::DoDataExchange(CDataExchange* pDX) |
| { |
| CDialog::DoDataExchange(pDX); |
| } |
| |
| |
| BEGIN_MESSAGE_MAP(CTelephonyEvent, CDialog) |
| ON_BN_CLICKED(IDC_BUTTON_1, &CTelephonyEvent::OnBnClickedButton1) |
| ON_BN_CLICKED(IDC_BUTTON_2, &CTelephonyEvent::OnBnClickedButton2) |
| ON_BN_CLICKED(IDC_BUTTON_3, &CTelephonyEvent::OnBnClickedButton3) |
| ON_BN_CLICKED(IDC_BUTTON_4, &CTelephonyEvent::OnBnClickedButton4) |
| ON_BN_CLICKED(IDC_BUTTON_5, &CTelephonyEvent::OnBnClickedButton5) |
| ON_BN_CLICKED(IDC_BUTTON_6, &CTelephonyEvent::OnBnClickedButton6) |
| ON_BN_CLICKED(IDC_BUTTON_7, &CTelephonyEvent::OnBnClickedButton7) |
| ON_BN_CLICKED(IDC_BUTTON_8, &CTelephonyEvent::OnBnClickedButton8) |
| ON_BN_CLICKED(IDC_BUTTON_9, &CTelephonyEvent::OnBnClickedButton9) |
| ON_BN_CLICKED(IDC_BUTTON_10, &CTelephonyEvent::OnBnClickedButton10) |
| ON_BN_CLICKED(IDC_BUTTON_11, &CTelephonyEvent::OnBnClickedButton11) |
| ON_BN_CLICKED(IDC_BUTTON_12, &CTelephonyEvent::OnBnClickedButton12) |
| ON_BN_CLICKED(IDC_BUTTON_13, &CTelephonyEvent::OnBnClickedButtonA) |
| ON_BN_CLICKED(IDC_BUTTON_14, &CTelephonyEvent::OnBnClickedButtonB) |
| ON_BN_CLICKED(IDC_BUTTON_15, &CTelephonyEvent::OnBnClickedButtonC) |
| ON_BN_CLICKED(IDC_BUTTON_16, &CTelephonyEvent::OnBnClickedButtonD) |
| ON_BN_CLICKED(IDC_CHECK_DTMF_PLAYOUT_RX, &CTelephonyEvent::OnBnClickedCheckDtmfPlayoutRx) |
| ON_BN_CLICKED(IDC_CHECK_DTMF_PLAY_TONE, &CTelephonyEvent::OnBnClickedCheckDtmfPlayTone) |
| ON_BN_CLICKED(IDC_CHECK_EVENT_INBAND, &CTelephonyEvent::OnBnClickedCheckEventInband) |
| ON_BN_CLICKED(IDC_CHECK_DTMF_FEEDBACK, &CTelephonyEvent::OnBnClickedCheckDtmfFeedback) |
| ON_BN_CLICKED(IDC_CHECK_DIRECT_FEEDBACK, &CTelephonyEvent::OnBnClickedCheckDirectFeedback) |
| ON_BN_CLICKED(IDC_RADIO_SINGLE, &CTelephonyEvent::OnBnClickedRadioSingle) |
| ON_BN_CLICKED(IDC_RADIO_MULTI, &CTelephonyEvent::OnBnClickedRadioMulti) |
| ON_BN_CLICKED(IDC_RADIO_START_STOP, &CTelephonyEvent::OnBnClickedRadioStartStop) |
| ON_BN_CLICKED(IDC_BUTTON_SET_RX_TELEPHONE_PT, &CTelephonyEvent::OnBnClickedButtonSetRxTelephonePt) |
| ON_BN_CLICKED(IDC_BUTTON_SET_TX_TELEPHONE_PT, &CTelephonyEvent::OnBnClickedButtonSetTxTelephonePt) |
| ON_BN_CLICKED(IDC_BUTTON_SEND_TELEPHONE_EVENT, &CTelephonyEvent::OnBnClickedButtonSendTelephoneEvent) |
| ON_BN_CLICKED(IDC_CHECK_DETECT_INBAND, &CTelephonyEvent::OnBnClickedCheckDetectInband) |
| ON_BN_CLICKED(IDC_CHECK_DETECT_OUT_OF_BAND, &CTelephonyEvent::OnBnClickedCheckDetectOutOfBand) |
| ON_BN_CLICKED(IDC_CHECK_EVENT_DETECTION, &CTelephonyEvent::OnBnClickedCheckEventDetection) |
| END_MESSAGE_MAP() |
| |
| |
| // CTelephonyEvent message handlers |
| |
| BOOL CTelephonyEvent::OnInitDialog() |
| { |
| CDialog::OnInitDialog(); |
| |
| CString str; |
| GetWindowText(str); |
| str.AppendFormat(_T(" [channel = %d]"), _channel); |
| SetWindowText(str); |
| |
| // Update dialog with latest playout state |
| bool enabled(false); |
| _veDTMFPtr->GetDtmfPlayoutStatus(_channel, enabled); |
| CButton* button = (CButton*)GetDlgItem(IDC_CHECK_DTMF_PLAYOUT_RX); |
| button->SetCheck(enabled ? BST_CHECKED : BST_UNCHECKED); |
| |
| // Update dialog with latest feedback state |
| bool directFeedback(false); |
| _veDTMFPtr->GetDtmfFeedbackStatus(enabled, directFeedback); |
| button = (CButton*)GetDlgItem(IDC_CHECK_DTMF_FEEDBACK); |
| button->SetCheck(enabled ? BST_CHECKED : BST_UNCHECKED); |
| button = (CButton*)GetDlgItem(IDC_CHECK_DIRECT_FEEDBACK); |
| button->SetCheck(directFeedback ? BST_CHECKED : BST_UNCHECKED); |
| |
| // Default event length is 160 ms |
| SetDlgItemInt(IDC_EDIT_EVENT_LENGTH, 160); |
| |
| // Default event attenuation is 10 (<-> -10dBm0) |
| SetDlgItemInt(IDC_EDIT_EVENT_ATTENUATION, 10); |
| |
| // Current event-detection status |
| TelephoneEventDetectionMethods detectionMethod(kOutOfBand); |
| if (_veDTMFPtr->GetTelephoneEventDetectionStatus(_channel, enabled, detectionMethod) == 0) |
| { |
| // DTMF detection is supported |
| if (enabled) |
| { |
| button = (CButton*)GetDlgItem(IDC_CHECK_EVENT_DETECTION); |
| button->SetCheck(BST_CHECKED); |
| } |
| if (detectionMethod == kOutOfBand || detectionMethod == kInAndOutOfBand) |
| { |
| button = (CButton*)GetDlgItem(IDC_CHECK_DETECT_OUT_OF_BAND); |
| button->SetCheck(BST_CHECKED); |
| } |
| if (detectionMethod == kInBand || detectionMethod == kInAndOutOfBand) |
| { |
| button = (CButton*)GetDlgItem(IDC_CHECK_DETECT_INBAND); |
| button->SetCheck(BST_CHECKED); |
| } |
| } |
| else |
| { |
| // DTMF detection is not supported |
| GetDlgItem(IDC_CHECK_EVENT_DETECTION)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_DETECT_OUT_OF_BAND)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_DETECT_INBAND)->EnableWindow(FALSE); |
| GetDlgItem(IDC_EDIT_ON_EVENT_INBAND)->EnableWindow(FALSE); |
| GetDlgItem(IDC_EDIT_ON_EVENT_OUT_OF_BAND)->EnableWindow(FALSE); |
| } |
| |
| // Telephone-event PTs |
| unsigned char pt(0); |
| _veDTMFPtr->GetSendTelephoneEventPayloadType(_channel, pt); |
| SetDlgItemInt(IDC_EDIT_EVENT_TX_PT, pt); |
| |
| CodecInst codec; |
| strcpy_s(codec.plname, 32, "telephone-event"); codec.channels = 1; codec.plfreq = 8000; |
| _veCodecPtr->GetRecPayloadType(_channel, codec); |
| SetDlgItemInt(IDC_EDIT_EVENT_RX_PT, codec.pltype); |
| |
| if (_modeSingle) |
| { |
| ((CButton*)GetDlgItem(IDC_RADIO_SINGLE))->SetCheck(BST_CHECKED); |
| } |
| else if (_modeStartStop) |
| { |
| ((CButton*)GetDlgItem(IDC_RADIO_START_STOP))->SetCheck(BST_CHECKED); |
| } |
| else if (_modeSequence) |
| { |
| ((CButton*)GetDlgItem(IDC_RADIO_MULTI))->SetCheck(BST_CHECKED); |
| } |
| |
| return TRUE; // return TRUE unless you set the focus to a control |
| } |
| void CTelephonyEvent::SendTelephoneEvent(unsigned char eventCode) |
| { |
| BOOL ret; |
| int lengthMs(0); |
| int attenuationDb(0); |
| bool outBand(false); |
| int res(0); |
| |
| // tone length |
| if (!_modeStartStop) |
| { |
| lengthMs = GetDlgItemInt(IDC_EDIT_EVENT_LENGTH, &ret); |
| if (ret == FALSE) |
| { |
| // use default length if edit field is empty |
| lengthMs = 160; |
| } |
| } |
| |
| // attenuation |
| attenuationDb = GetDlgItemInt(IDC_EDIT_EVENT_ATTENUATION, &ret); |
| if (ret == FALSE) |
| { |
| // use default length if edit field is empty |
| attenuationDb = 10; |
| } |
| |
| // out-band or in-band |
| CButton* button = (CButton*)GetDlgItem(IDC_CHECK_EVENT_INBAND); |
| int check = button->GetCheck(); |
| outBand = (check == BST_UNCHECKED); |
| |
| if (eventCode < 16) |
| SetDlgItemInt(IDC_EDIT_DTMF_EVENT, eventCode); |
| |
| if (_PlayDtmfToneLocally) |
| { |
| // --- PlayDtmfTone |
| |
| if (_modeSingle) |
| { |
| TEST2(_veDTMFPtr->PlayDtmfTone(eventCode, lengthMs, attenuationDb) == 0, |
| _T("PlayDtmfTone(eventCode=%u, lengthMs=%d, attenuationDb=%d)"), eventCode, lengthMs, attenuationDb); |
| } |
| else if (_modeStartStop) |
| { |
| if (!_playingDTMFTone) |
| { |
| TEST2((res = _veDTMFPtr->StartPlayingDtmfTone(eventCode, attenuationDb)) == 0, |
| _T("StartPlayingDtmfTone(eventCode=%u, attenuationDb=%d)"), eventCode, attenuationDb); |
| } |
| else |
| { |
| TEST2((res = _veDTMFPtr->StopPlayingDtmfTone()) == 0, |
| _T("StopPlayingDTMFTone()")); |
| } |
| if (res == 0) |
| _playingDTMFTone = !_playingDTMFTone; |
| } |
| else if (_modeSequence) |
| { |
| int nTones(1); |
| int sleepMs(0); |
| int lenMult(1); |
| if (eventCode == 1) |
| { |
| nTones = 2; |
| sleepMs = lengthMs; |
| lenMult = 1; |
| } |
| else if (eventCode == 2) |
| { |
| nTones = 2; |
| sleepMs = lengthMs/2; |
| lenMult = 2; |
| } |
| else if (eventCode == 3) |
| { |
| nTones = 3; |
| sleepMs = 0; |
| lenMult = 1; |
| } |
| for (int i = 0; i < nTones; i++) |
| { |
| TEST2(_veDTMFPtr->PlayDtmfTone(eventCode, lengthMs, attenuationDb) == 0, |
| _T("PlayDtmfTone(eventCode=%u, outBand=%d, lengthMs=%d, attenuationDb=%d)"), eventCode, lengthMs, attenuationDb); |
| Sleep(sleepMs); |
| lengthMs = lenMult*lengthMs; |
| eventCode++; |
| } |
| } |
| } |
| else |
| { |
| // --- SendTelephoneEvent |
| |
| if (_modeSingle) |
| { |
| TEST2(_veDTMFPtr->SendTelephoneEvent(_channel, eventCode, outBand, lengthMs, attenuationDb) == 0, |
| _T("SendTelephoneEvent(channel=%d, eventCode=%u, outBand=%d, lengthMs=%d, attenuationDb=%d)"), _channel, eventCode, outBand, lengthMs, attenuationDb); |
| } |
| else if (_modeStartStop) |
| { |
| TEST2(false, _T("*** NOT IMPLEMENTED ***")); |
| } |
| else if (_modeSequence) |
| { |
| int nTones(1); |
| int sleepMs(0); |
| int lenMult(1); |
| if (eventCode == 1) |
| { |
| nTones = 2; |
| sleepMs = lengthMs; |
| lenMult = 1; |
| } |
| else if (eventCode == 2) |
| { |
| eventCode = 1; |
| nTones = 2; |
| sleepMs = lengthMs/2; |
| lenMult = 2; |
| } |
| else if (eventCode == 3) |
| { |
| eventCode = 1; |
| nTones = 3; |
| sleepMs = 0; |
| lenMult = 1; |
| } |
| for (int i = 0; i < nTones; i++) |
| { |
| TEST2(_veDTMFPtr->SendTelephoneEvent(_channel, eventCode, outBand, lengthMs, attenuationDb) == 0, |
| _T("SendTelephoneEvent(channel=%d, eventCode=%u, outBand=%d, lengthMs=%d, attenuationDb=%d)"), _channel, eventCode, outBand, lengthMs, attenuationDb); |
| Sleep(sleepMs); |
| lengthMs = lenMult*lengthMs; |
| eventCode++; |
| } |
| } |
| } |
| } |
| |
| void CTelephonyEvent::OnBnClickedButtonSendTelephoneEvent() |
| { |
| BOOL ret; |
| unsigned char eventCode(0); |
| |
| eventCode = (unsigned char)GetDlgItemInt(IDC_EDIT_EVENT_CODE, &ret); |
| if (ret == FALSE) |
| { |
| return; |
| } |
| SendTelephoneEvent(eventCode); |
| } |
| |
| void CTelephonyEvent::OnBnClickedButton1() |
| { |
| SendTelephoneEvent(1); |
| } |
| |
| void CTelephonyEvent::OnBnClickedButton2() |
| { |
| SendTelephoneEvent(2); |
| } |
| |
| void CTelephonyEvent::OnBnClickedButton3() |
| { |
| SendTelephoneEvent(3); |
| } |
| |
| void CTelephonyEvent::OnBnClickedButton4() |
| { |
| SendTelephoneEvent(4); |
| } |
| |
| void CTelephonyEvent::OnBnClickedButton5() |
| { |
| SendTelephoneEvent(5); |
| } |
| |
| void CTelephonyEvent::OnBnClickedButton6() |
| { |
| SendTelephoneEvent(6); |
| } |
| |
| void CTelephonyEvent::OnBnClickedButton7() |
| { |
| SendTelephoneEvent(7); |
| } |
| |
| void CTelephonyEvent::OnBnClickedButton8() |
| { |
| SendTelephoneEvent(8); |
| } |
| |
| void CTelephonyEvent::OnBnClickedButton9() |
| { |
| SendTelephoneEvent(9); |
| } |
| |
| void CTelephonyEvent::OnBnClickedButton10() |
| { |
| // * |
| SendTelephoneEvent(10); |
| } |
| |
| void CTelephonyEvent::OnBnClickedButton11() |
| { |
| SendTelephoneEvent(0); |
| } |
| |
| void CTelephonyEvent::OnBnClickedButton12() |
| { |
| // # |
| SendTelephoneEvent(11); |
| } |
| |
| void CTelephonyEvent::OnBnClickedButtonA() |
| { |
| SendTelephoneEvent(12); |
| } |
| |
| void CTelephonyEvent::OnBnClickedButtonB() |
| { |
| SendTelephoneEvent(13); |
| } |
| |
| void CTelephonyEvent::OnBnClickedButtonC() |
| { |
| SendTelephoneEvent(14); |
| } |
| |
| void CTelephonyEvent::OnBnClickedButtonD() |
| { |
| SendTelephoneEvent(15); |
| } |
| |
| void CTelephonyEvent::OnBnClickedCheckDtmfPlayoutRx() |
| { |
| CButton* button = (CButton*)GetDlgItem(IDC_CHECK_DTMF_PLAYOUT_RX); |
| int check = button->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| TEST2(_veDTMFPtr->SetDtmfPlayoutStatus(_channel, enable) == 0, _T("SetDtmfPlayoutStatus(channel=%d, enable=%d)"), _channel, enable); |
| } |
| |
| void CTelephonyEvent::OnBnClickedCheckDtmfPlayTone() |
| { |
| CButton* button = (CButton*)GetDlgItem(IDC_CHECK_DTMF_PLAY_TONE); |
| int check = button->GetCheck(); |
| _PlayDtmfToneLocally = (check == BST_CHECKED); |
| } |
| |
| void CTelephonyEvent::OnBnClickedRadioSingle() |
| { |
| _modeStartStop = false; |
| _modeSingle = true; |
| _modeSequence = false; |
| } |
| |
| void CTelephonyEvent::OnBnClickedRadioMulti() |
| { |
| _modeStartStop = false; |
| _modeSingle = false; |
| _modeSequence = true; |
| } |
| |
| void CTelephonyEvent::OnBnClickedRadioStartStop() |
| { |
| // CButton* button = (CButton*)GetDlgItem(IDC_RADIO_START_STOP); |
| // int check = button->GetCheck(); |
| _modeStartStop = true; |
| _modeSingle = false; |
| _modeSequence = false; |
| // GetDlgItem(IDC_EDIT_EVENT_LENGTH)->EnableWindow(); |
| } |
| |
| void CTelephonyEvent::OnBnClickedCheckEventInband() |
| { |
| CButton* button = (CButton*)GetDlgItem(IDC_CHECK_EVENT_INBAND); |
| int check = button->GetCheck(); |
| GetDlgItem(IDC_EDIT_EVENT_CODE)->EnableWindow(check?FALSE:TRUE); |
| GetDlgItem(IDC_BUTTON_SEND_TELEPHONE_EVENT)->EnableWindow(check?FALSE:TRUE); |
| } |
| |
| void CTelephonyEvent::OnBnClickedCheckDtmfFeedback() |
| { |
| CButton* button(NULL); |
| |
| // Retrieve feedback state |
| button = (CButton*)GetDlgItem(IDC_CHECK_DTMF_FEEDBACK); |
| int check = button->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| |
| // Retrieve direct-feedback setting |
| button = (CButton*)GetDlgItem(IDC_CHECK_DIRECT_FEEDBACK); |
| check = button->GetCheck(); |
| const bool directFeedback = (check == BST_CHECKED); |
| |
| // GetDlgItem(IDC_CHECK_DIRECT_FEEDBACK)->EnableWindow(enable ? TRUE : FALSE); |
| |
| TEST2(_veDTMFPtr->SetDtmfFeedbackStatus(enable, directFeedback) == 0, |
| _T("SetDtmfFeedbackStatus(enable=%d, directFeedback=%d)"), enable, directFeedback); |
| } |
| |
| void CTelephonyEvent::OnBnClickedCheckDirectFeedback() |
| { |
| CButton* button(NULL); |
| |
| // Retrieve feedback state |
| button = (CButton*)GetDlgItem(IDC_CHECK_DTMF_FEEDBACK); |
| int check = button->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| |
| // Retrieve new direct-feedback setting |
| button = (CButton*)GetDlgItem(IDC_CHECK_DIRECT_FEEDBACK); |
| check = button->GetCheck(); |
| const bool directFeedback = (check == BST_CHECKED); |
| |
| TEST2(_veDTMFPtr->SetDtmfFeedbackStatus(enable, directFeedback) == 0, |
| _T("SetDtmfFeedbackStatus(enable=%d, directFeedback=%d)"), enable, directFeedback); |
| } |
| |
| void CTelephonyEvent::OnBnClickedButtonSetRxTelephonePt() |
| { |
| BOOL ret; |
| int pt = GetDlgItemInt(IDC_EDIT_EVENT_RX_PT, &ret); |
| if (ret == FALSE) |
| return; |
| CodecInst codec; |
| strcpy_s(codec.plname, 32, "telephone-event"); |
| codec.pltype = pt; codec.channels = 1; codec.plfreq = 8000; |
| TEST2(_veCodecPtr->SetRecPayloadType(_channel, codec) == 0, |
| _T("SetSendTelephoneEventPayloadType(channel=%d, codec.pltype=%u)"), _channel, codec.pltype); |
| } |
| |
| void CTelephonyEvent::OnBnClickedButtonSetTxTelephonePt() |
| { |
| BOOL ret; |
| int pt = GetDlgItemInt(IDC_EDIT_EVENT_TX_PT, &ret); |
| if (ret == FALSE) |
| return; |
| TEST2(_veDTMFPtr->SetSendTelephoneEventPayloadType(_channel, pt) == 0, |
| _T("SetSendTelephoneEventPayloadType(channel=%d, type=%u)"), _channel, pt); |
| } |
| |
| void CTelephonyEvent::OnBnClickedCheckDetectInband() |
| { |
| CButton* button = (CButton*)GetDlgItem(IDC_CHECK_DETECT_INBAND); |
| int check = button->GetCheck(); |
| _inbandEventDetection = (check == BST_CHECKED); |
| |
| bool enabled(false); |
| TelephoneEventDetectionMethods detectionMethod; |
| _veDTMFPtr->GetTelephoneEventDetectionStatus(_channel, enabled, detectionMethod); |
| if (enabled) |
| { |
| // deregister |
| _veDTMFPtr->DeRegisterTelephoneEventDetection(_channel); |
| delete _telephoneEventObserverPtr; |
| _telephoneEventObserverPtr = NULL; |
| SetDlgItemText(IDC_EDIT_ON_EVENT_INBAND,_T("")); |
| SetDlgItemText(IDC_EDIT_ON_EVENT_OUT_OF_BAND,_T("")); |
| } |
| OnBnClickedCheckEventDetection(); |
| } |
| |
| void CTelephonyEvent::OnBnClickedCheckDetectOutOfBand() |
| { |
| CButton* button = (CButton*)GetDlgItem(IDC_CHECK_DETECT_OUT_OF_BAND); |
| int check = button->GetCheck(); |
| _outOfBandEventDetection = (check == BST_CHECKED); |
| |
| bool enabled(false); |
| TelephoneEventDetectionMethods detectionMethod; |
| _veDTMFPtr->GetTelephoneEventDetectionStatus(_channel, enabled, detectionMethod); |
| if (enabled) |
| { |
| // deregister |
| _veDTMFPtr->DeRegisterTelephoneEventDetection(_channel); |
| delete _telephoneEventObserverPtr; |
| _telephoneEventObserverPtr = NULL; |
| SetDlgItemText(IDC_EDIT_ON_EVENT_INBAND,_T("")); |
| SetDlgItemText(IDC_EDIT_ON_EVENT_OUT_OF_BAND,_T("")); |
| } |
| OnBnClickedCheckEventDetection(); |
| } |
| |
| void CTelephonyEvent::OnBnClickedCheckEventDetection() |
| { |
| CButton* button = (CButton*)GetDlgItem(IDC_CHECK_EVENT_DETECTION); |
| int check = button->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| |
| if (enable) |
| { |
| TelephoneEventDetectionMethods method(kInBand); |
| if (_inbandEventDetection && !_outOfBandEventDetection) |
| method = kInBand; |
| else if (!_inbandEventDetection && _outOfBandEventDetection) |
| method = kOutOfBand; |
| else if (_inbandEventDetection && _outOfBandEventDetection) |
| method = kInAndOutOfBand; |
| |
| CWnd* wndOut = GetDlgItem(IDC_EDIT_ON_EVENT_OUT_OF_BAND); |
| CWnd* wndIn = GetDlgItem(IDC_EDIT_ON_EVENT_INBAND); |
| _telephoneEventObserverPtr = new TelephoneEventObserver(wndOut, wndIn); |
| |
| TEST2(_veDTMFPtr->RegisterTelephoneEventDetection(_channel, method, *_telephoneEventObserverPtr) == 0, |
| _T("RegisterTelephoneEventDetection(channel=%d, detectionMethod=%d)"), _channel, method); |
| } |
| else |
| { |
| TEST2(_veDTMFPtr->DeRegisterTelephoneEventDetection(_channel) == 0, |
| _T("DeRegisterTelephoneEventDetection(channel=%d)"), _channel); |
| delete _telephoneEventObserverPtr; |
| _telephoneEventObserverPtr = NULL; |
| SetDlgItemText(IDC_EDIT_ON_EVENT_INBAND,_T("")); |
| SetDlgItemText(IDC_EDIT_ON_EVENT_OUT_OF_BAND,_T("")); |
| } |
| } |
| |
| // ============================================================================ |
| // CWinTestDlg dialog |
| // ============================================================================ |
| |
| CWinTestDlg::CWinTestDlg(CWnd* pParent /*=NULL*/) |
| : CDialog(CWinTestDlg::IDD, pParent), |
| _failCount(0), |
| _vePtr(NULL), |
| _veBasePtr(NULL), |
| _veCodecPtr(NULL), |
| _veNetworkPtr(NULL), |
| _veFilePtr(NULL), |
| _veHardwarePtr(NULL), |
| _veExternalMediaPtr(NULL), |
| _veApmPtr(NULL), |
| _veEncryptionPtr(NULL), |
| _veRtpRtcpPtr(NULL), |
| _transportPtr(NULL), |
| _encryptionPtr(NULL), |
| _externalMediaPtr(NULL), |
| _externalTransport(false), |
| _externalTransportBuild(false), |
| _checkPlayFileIn(0), |
| _checkPlayFileIn1(0), |
| _checkPlayFileIn2(0), |
| _checkPlayFileOut1(0), |
| _checkPlayFileOut2(0), |
| _checkAGC(0), |
| _checkAGC1(0), |
| _checkNS(0), |
| _checkNS1(0), |
| _checkEC(0), |
| _checkVAD1(0), |
| _checkVAD2(0), |
| _checkSrtpTx1(0), |
| _checkSrtpTx2(0), |
| _checkSrtpRx1(0), |
| _checkSrtpRx2(0), |
| _checkConference1(0), |
| _checkConference2(0), |
| _checkOnHold1(0), |
| _checkOnHold2(0), |
| _strComboIp1(_T("")), |
| _strComboIp2(_T("")), |
| _delayEstimate1(false), |
| _delayEstimate2(false), |
| _rxVad(false), |
| _nErrorCallbacks(0), |
| _timerTicks(0) |
| { |
| m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME); |
| |
| _vePtr = VoiceEngine::Create(); |
| |
| VoiceEngine::SetTraceFilter(kTraceNone); |
| // VoiceEngine::SetTraceFilter(kTraceAll); |
| // VoiceEngine::SetTraceFilter(kTraceStream | kTraceStateInfo | kTraceWarning | kTraceError | kTraceCritical | kTraceApiCall | kTraceModuleCall | kTraceMemory | kTraceDebug | kTraceInfo); |
| // VoiceEngine::SetTraceFilter(kTraceStateInfo | kTraceWarning | kTraceError | kTraceCritical | kTraceApiCall | kTraceModuleCall | kTraceMemory | kTraceInfo); |
| |
| VoiceEngine::SetTraceFile("ve_win_test.txt"); |
| VoiceEngine::SetTraceCallback(NULL); |
| |
| if (_vePtr) |
| { |
| _veExternalMediaPtr = VoEExternalMedia::GetInterface(_vePtr); |
| _veVolumeControlPtr = VoEVolumeControl::GetInterface(_vePtr); |
| _veEncryptionPtr = VoEEncryption::GetInterface(_vePtr); |
| _veVideoSyncPtr = VoEVideoSync::GetInterface(_vePtr); |
| _veNetworkPtr = VoENetwork::GetInterface(_vePtr); |
| _veFilePtr = VoEFile::GetInterface(_vePtr); |
| _veApmPtr = VoEAudioProcessing::GetInterface(_vePtr); |
| |
| _veBasePtr = VoEBase::GetInterface(_vePtr); |
| _veCodecPtr = VoECodec::GetInterface(_vePtr); |
| _veHardwarePtr = VoEHardware::GetInterface(_vePtr); |
| _veRtpRtcpPtr = VoERTP_RTCP::GetInterface(_vePtr); |
| _transportPtr = new MyTransport(_veNetworkPtr); |
| _encryptionPtr = new MyEncryption(); |
| _externalMediaPtr = new MediaProcessImpl(); |
| _connectionObserverPtr = new ConnectionObserver(); |
| _rxVadObserverPtr = new RxCallback(); |
| } |
| |
| _veBasePtr->RegisterVoiceEngineObserver(*this); |
| } |
| |
| CWinTestDlg::~CWinTestDlg() |
| { |
| if (_connectionObserverPtr) delete _connectionObserverPtr; |
| if (_externalMediaPtr) delete _externalMediaPtr; |
| if (_transportPtr) delete _transportPtr; |
| if (_encryptionPtr) delete _encryptionPtr; |
| if (_rxVadObserverPtr) delete _rxVadObserverPtr; |
| |
| if (_veExternalMediaPtr) _veExternalMediaPtr->Release(); |
| if (_veEncryptionPtr) _veEncryptionPtr->Release(); |
| if (_veVideoSyncPtr) _veVideoSyncPtr->Release(); |
| if (_veVolumeControlPtr) _veVolumeControlPtr->Release(); |
| |
| if (_veBasePtr) _veBasePtr->Terminate(); |
| if (_veBasePtr) _veBasePtr->Release(); |
| |
| if (_veCodecPtr) _veCodecPtr->Release(); |
| if (_veNetworkPtr) _veNetworkPtr->Release(); |
| if (_veFilePtr) _veFilePtr->Release(); |
| if (_veHardwarePtr) _veHardwarePtr->Release(); |
| if (_veApmPtr) _veApmPtr->Release(); |
| if (_veRtpRtcpPtr) _veRtpRtcpPtr->Release(); |
| if (_vePtr) |
| { |
| bool ret = VoiceEngine::Delete(_vePtr); |
| ASSERT(ret == true); |
| } |
| VoiceEngine::SetTraceFilter(kTraceNone); |
| } |
| |
| void CWinTestDlg::DoDataExchange(CDataExchange* pDX) |
| { |
| CDialog::DoDataExchange(pDX); |
| DDX_CBString(pDX, IDC_COMBO_IP_1, _strComboIp1); |
| DDX_CBString(pDX, IDC_COMBO_IP_2, _strComboIp2); |
| } |
| |
| BEGIN_MESSAGE_MAP(CWinTestDlg, CDialog) |
| ON_WM_SYSCOMMAND() |
| ON_WM_PAINT() |
| ON_WM_QUERYDRAGICON() |
| ON_WM_TIMER() |
| //}}AFX_MSG_MAP |
| ON_BN_CLICKED(IDC_BUTTON_CREATE_1, &CWinTestDlg::OnBnClickedButtonCreate1) |
| ON_BN_CLICKED(IDC_BUTTON_DELETE_1, &CWinTestDlg::OnBnClickedButtonDelete1) |
| ON_BN_CLICKED(IDC_BUTTON_CREATE_2, &CWinTestDlg::OnBnClickedButtonCreate2) |
| ON_BN_CLICKED(IDC_BUTTON_DELETE_2, &CWinTestDlg::OnBnClickedButtonDelete2) |
| ON_CBN_SELCHANGE(IDC_COMBO_CODEC_1, &CWinTestDlg::OnCbnSelchangeComboCodec1) |
| ON_BN_CLICKED(IDC_BUTTON_START_LISTEN_1, &CWinTestDlg::OnBnClickedButtonStartListen1) |
| ON_BN_CLICKED(IDC_BUTTON_STOP_LISTEN_1, &CWinTestDlg::OnBnClickedButtonStopListen1) |
| ON_BN_CLICKED(IDC_BUTTON_START_PLAYOUT_1, &CWinTestDlg::OnBnClickedButtonStartPlayout1) |
| ON_BN_CLICKED(IDC_BUTTON_STOP_PLAYOUT_1, &CWinTestDlg::OnBnClickedButtonStopPlayout1) |
| ON_BN_CLICKED(IDC_BUTTON_START_SEND_1, &CWinTestDlg::OnBnClickedButtonStartSend1) |
| ON_BN_CLICKED(IDC_BUTTON_STOP_SEND_1, &CWinTestDlg::OnBnClickedButtonStopSend1) |
| ON_CBN_SELCHANGE(IDC_COMBO_IP_2, &CWinTestDlg::OnCbnSelchangeComboIp2) |
| ON_CBN_SELCHANGE(IDC_COMBO_IP_1, &CWinTestDlg::OnCbnSelchangeComboIp1) |
| ON_CBN_SELCHANGE(IDC_COMBO_CODEC_2, &CWinTestDlg::OnCbnSelchangeComboCodec2) |
| ON_BN_CLICKED(IDC_BUTTON_START_LISTEN_2, &CWinTestDlg::OnBnClickedButtonStartListen2) |
| ON_BN_CLICKED(IDC_BUTTON_STOP_LISTEN_2, &CWinTestDlg::OnBnClickedButtonStopListen2) |
| ON_BN_CLICKED(IDC_BUTTON_START_PLAYOUT_2, &CWinTestDlg::OnBnClickedButtonStartPlayout2) |
| ON_BN_CLICKED(IDC_BUTTON_STOP_PLAYOUT_2, &CWinTestDlg::OnBnClickedButtonStopPlayout2) |
| ON_BN_CLICKED(IDC_BUTTON_START_SEND_2, &CWinTestDlg::OnBnClickedButtonStartSend2) |
| ON_BN_CLICKED(IDC_BUTTON_STOP_SEND_2, &CWinTestDlg::OnBnClickedButtonStopSend2) |
| ON_BN_CLICKED(IDC_CHECK_EXT_TRANS_1, &CWinTestDlg::OnBnClickedCheckExtTrans1) |
| ON_BN_CLICKED(IDC_CHECK_PLAY_FILE_IN_1, &CWinTestDlg::OnBnClickedCheckPlayFileIn1) |
| ON_BN_CLICKED(IDC_CHECK_PLAY_FILE_OUT_1, &CWinTestDlg::OnBnClickedCheckPlayFileOut1) |
| ON_BN_CLICKED(IDC_CHECK_EXT_TRANS_2, &CWinTestDlg::OnBnClickedCheckExtTrans2) |
| ON_BN_CLICKED(IDC_CHECK_PLAY_FILE_IN_2, &CWinTestDlg::OnBnClickedCheckPlayFileIn2) |
| ON_BN_CLICKED(IDC_CHECK_PLAY_FILE_OUT_2, &CWinTestDlg::OnBnClickedCheckPlayFileOut2) |
| ON_BN_CLICKED(IDC_CHECK_PLAY_FILE_IN, &CWinTestDlg::OnBnClickedCheckPlayFileIn) |
| ON_CBN_SELCHANGE(IDC_COMBO_REC_DEVICE, &CWinTestDlg::OnCbnSelchangeComboRecDevice) |
| ON_CBN_SELCHANGE(IDC_COMBO_PLAY_DEVICE, &CWinTestDlg::OnCbnSelchangeComboPlayDevice) |
| ON_BN_CLICKED(IDC_CHECK_EXT_MEDIA_IN_1, &CWinTestDlg::OnBnClickedCheckExtMediaIn1) |
| ON_BN_CLICKED(IDC_CHECK_EXT_MEDIA_OUT_1, &CWinTestDlg::OnBnClickedCheckExtMediaOut1) |
| ON_NOTIFY(NM_RELEASEDCAPTURE, IDC_SLIDER_INPUT_VOLUME, &CWinTestDlg::OnNMReleasedcaptureSliderInputVolume) |
| ON_NOTIFY(NM_RELEASEDCAPTURE, IDC_SLIDER_OUTPUT_VOLUME, &CWinTestDlg::OnNMReleasedcaptureSliderOutputVolume) |
| ON_BN_CLICKED(IDC_CHECK_AGC, &CWinTestDlg::OnBnClickedCheckAgc) |
| ON_BN_CLICKED(IDC_CHECK_NS, &CWinTestDlg::OnBnClickedCheckNs) |
| ON_BN_CLICKED(IDC_CHECK_EC, &CWinTestDlg::OnBnClickedCheckEc) |
| ON_BN_CLICKED(IDC_CHECK_VAD_1, &CWinTestDlg::OnBnClickedCheckVad1) |
| ON_BN_CLICKED(IDC_CHECK_VAD_3, &CWinTestDlg::OnBnClickedCheckVad2) |
| ON_BN_CLICKED(IDC_CHECK_EXT_MEDIA_IN_2, &CWinTestDlg::OnBnClickedCheckExtMediaIn2) |
| ON_BN_CLICKED(IDC_CHECK_EXT_MEDIA_OUT_2, &CWinTestDlg::OnBnClickedCheckExtMediaOut2) |
| ON_BN_CLICKED(IDC_CHECK_MUTE_IN, &CWinTestDlg::OnBnClickedCheckMuteIn) |
| ON_BN_CLICKED(IDC_CHECK_MUTE_IN_1, &CWinTestDlg::OnBnClickedCheckMuteIn1) |
| ON_BN_CLICKED(IDC_CHECK_MUTE_IN_2, &CWinTestDlg::OnBnClickedCheckMuteIn2) |
| ON_BN_CLICKED(IDC_CHECK_SRTP_TX_1, &CWinTestDlg::OnBnClickedCheckSrtpTx1) |
| ON_BN_CLICKED(IDC_CHECK_SRTP_RX_1, &CWinTestDlg::OnBnClickedCheckSrtpRx1) |
| ON_BN_CLICKED(IDC_CHECK_SRTP_TX_2, &CWinTestDlg::OnBnClickedCheckSrtpTx2) |
| ON_BN_CLICKED(IDC_CHECK_SRTP_RX_2, &CWinTestDlg::OnBnClickedCheckSrtpRx2) |
| ON_BN_CLICKED(IDC_CHECK_EXT_ENCRYPTION_1, &CWinTestDlg::OnBnClickedCheckExtEncryption1) |
| ON_BN_CLICKED(IDC_CHECK_EXT_ENCRYPTION_2, &CWinTestDlg::OnBnClickedCheckExtEncryption2) |
| ON_BN_CLICKED(IDC_BUTTON_DTMF_1, &CWinTestDlg::OnBnClickedButtonDtmf1) |
| ON_BN_CLICKED(IDC_CHECK_REC_MIC, &CWinTestDlg::OnBnClickedCheckRecMic) |
| ON_BN_CLICKED(IDC_BUTTON_DTMF_2, &CWinTestDlg::OnBnClickedButtonDtmf2) |
| ON_BN_CLICKED(IDC_BUTTON_TEST_1, &CWinTestDlg::OnBnClickedButtonTest1) |
| ON_BN_CLICKED(IDC_CHECK_CONFERENCE_1, &CWinTestDlg::OnBnClickedCheckConference1) |
| ON_BN_CLICKED(IDC_CHECK_CONFERENCE_2, &CWinTestDlg::OnBnClickedCheckConference2) |
| ON_BN_CLICKED(IDC_CHECK_ON_HOLD_1, &CWinTestDlg::OnBnClickedCheckOnHold1) |
| ON_BN_CLICKED(IDC_CHECK_ON_HOLD_2, &CWinTestDlg::OnBnClickedCheckOnHold2) |
| ON_BN_CLICKED(IDC_CHECK_EXT_MEDIA_IN, &CWinTestDlg::OnBnClickedCheckExtMediaIn) |
| ON_BN_CLICKED(IDC_CHECK_EXT_MEDIA_OUT, &CWinTestDlg::OnBnClickedCheckExtMediaOut) |
| ON_LBN_SELCHANGE(IDC_LIST_CODEC_1, &CWinTestDlg::OnLbnSelchangeListCodec1) |
| ON_NOTIFY(NM_RELEASEDCAPTURE, IDC_SLIDER_PAN_LEFT, &CWinTestDlg::OnNMReleasedcaptureSliderPanLeft) |
| ON_NOTIFY(NM_RELEASEDCAPTURE, IDC_SLIDER_PAN_RIGHT, &CWinTestDlg::OnNMReleasedcaptureSliderPanRight) |
| ON_BN_CLICKED(IDC_BUTTON_VERSION, &CWinTestDlg::OnBnClickedButtonVersion) |
| ON_BN_CLICKED(IDC_CHECK_DELAY_ESTIMATE_1, &CWinTestDlg::OnBnClickedCheckDelayEstimate1) |
| ON_BN_CLICKED(IDC_CHECK_RXVAD, &CWinTestDlg::OnBnClickedCheckRxvad) |
| ON_BN_CLICKED(IDC_CHECK_AGC_1, &CWinTestDlg::OnBnClickedCheckAgc1) |
| ON_BN_CLICKED(IDC_CHECK_NS_1, &CWinTestDlg::OnBnClickedCheckNs1) |
| ON_BN_CLICKED(IDC_CHECK_REC_CALL, &CWinTestDlg::OnBnClickedCheckRecCall) |
| ON_BN_CLICKED(IDC_CHECK_TYPING_DETECTION, &CWinTestDlg::OnBnClickedCheckTypingDetection) |
| ON_BN_CLICKED(IDC_CHECK_FEC, &CWinTestDlg::OnBnClickedCheckFEC) |
| ON_BN_CLICKED(IDC_BUTTON_CLEAR_ERROR_CALLBACK, &CWinTestDlg::OnBnClickedButtonClearErrorCallback) |
| END_MESSAGE_MAP() |
| |
| BOOL CWinTestDlg::UpdateTest(bool failed, const CString& strMsg) |
| { |
| if (failed) |
| { |
| SetDlgItemText(IDC_EDIT_MESSAGE, strMsg); |
| _strErr.Format(_T("FAILED (error=%d)"), _veBasePtr->LastError()); |
| SetDlgItemText(IDC_EDIT_RESULT, _strErr); |
| _failCount++; |
| SetDlgItemInt(IDC_EDIT_N_FAILS, _failCount); |
| SetDlgItemInt(IDC_EDIT_LAST_ERROR, _veBasePtr->LastError()); |
| } |
| else |
| { |
| SetDlgItemText(IDC_EDIT_MESSAGE, strMsg); |
| SetDlgItemText(IDC_EDIT_RESULT, _T("OK")); |
| } |
| return TRUE; |
| } |
| |
| |
| // CWinTestDlg message handlers |
| |
| BOOL CWinTestDlg::OnInitDialog() |
| { |
| CDialog::OnInitDialog(); |
| |
| // Add "About..." menu item to system menu. |
| |
| // IDM_ABOUTBOX must be in the system command range. |
| ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX); |
| ASSERT(IDM_ABOUTBOX < 0xF000); |
| |
| CMenu* pSysMenu = GetSystemMenu(FALSE); |
| if (pSysMenu != NULL) |
| { |
| CString strAboutMenu; |
| strAboutMenu.LoadString(IDS_ABOUTBOX); |
| if (!strAboutMenu.IsEmpty()) |
| { |
| pSysMenu->AppendMenu(MF_SEPARATOR); |
| pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu); |
| } |
| } |
| |
| // Set the icon for this dialog. The framework does this automatically |
| // when the application's main window is not a dialog |
| SetIcon(m_hIcon, TRUE); // Set big icon |
| SetIcon(m_hIcon, FALSE); // Set small icon |
| |
| // char version[1024]; |
| // _veBasePtr->GetVersion(version); |
| // AfxMessageBox(version, MB_OK); |
| |
| if (_veBasePtr->Init() != 0) |
| { |
| AfxMessageBox(_T("Init() failed "), MB_OKCANCEL); |
| } |
| |
| int ch = _veBasePtr->CreateChannel(); |
| if (_veBasePtr->SetSendDestination(ch, 1234, "127.0.0.1") == -1) |
| { |
| if (_veBasePtr->LastError() == VE_EXTERNAL_TRANSPORT_ENABLED) |
| { |
| _strMsg.Format(_T("*** External transport build ***")); |
| SetDlgItemText(IDC_EDIT_MESSAGE, _strMsg); |
| _externalTransportBuild = true; |
| } |
| } |
| _veBasePtr->DeleteChannel(ch); |
| |
| // --- Add (preferred) local IPv4 address in title |
| |
| if (_veNetworkPtr) |
| { |
| char localIP[64]; |
| _veNetworkPtr->GetLocalIP(localIP); |
| CString str; |
| GetWindowText(str); |
| str.AppendFormat(_T(" [Local IPv4 address: %s]"), CharToTchar(localIP, 64)); |
| SetWindowText(str); |
| } |
| |
| // --- Volume sliders |
| |
| if (_veVolumeControlPtr) |
| { |
| unsigned int volume(0); |
| CSliderCtrl* slider(NULL); |
| |
| slider = (CSliderCtrl*)GetDlgItem(IDC_SLIDER_INPUT_VOLUME); |
| slider->SetRangeMin(0); |
| slider->SetRangeMax(255); |
| _veVolumeControlPtr->GetMicVolume(volume); |
| slider->SetPos(volume); |
| |
| slider = (CSliderCtrl*)GetDlgItem(IDC_SLIDER_OUTPUT_VOLUME); |
| slider->SetRangeMin(0); |
| slider->SetRangeMax(255); |
| _veVolumeControlPtr->GetSpeakerVolume(volume); |
| slider->SetPos(volume); |
| } |
| |
| // --- Panning sliders |
| |
| if (_veVolumeControlPtr) |
| { |
| float lVol(0.0); |
| float rVol(0.0); |
| int leftVol, rightVol; |
| unsigned int volumePan(0); |
| CSliderCtrl* slider(NULL); |
| |
| _veVolumeControlPtr->GetOutputVolumePan(-1, lVol, rVol); |
| |
| leftVol = (int)(lVol*10.0f); // [0,10] |
| rightVol = (int)(rVol*10.0f); // [0,10] |
| |
| slider = (CSliderCtrl*)GetDlgItem(IDC_SLIDER_PAN_LEFT); |
| slider->SetRange(0,10); |
| slider->SetPos(10-leftVol); // pos 0 <=> max pan 1.0 (top of slider) |
| |
| slider = (CSliderCtrl*)GetDlgItem(IDC_SLIDER_PAN_RIGHT); |
| slider->SetRange(0,10); |
| slider->SetPos(10-rightVol); |
| } |
| |
| // --- APM settings |
| |
| bool enable(false); |
| CButton* button(NULL); |
| |
| AgcModes agcMode(kAgcDefault); |
| if (_veApmPtr->GetAgcStatus(enable, agcMode) == 0) |
| { |
| button = (CButton*)GetDlgItem(IDC_CHECK_AGC); |
| enable ? button->SetCheck(BST_CHECKED) : button->SetCheck(BST_UNCHECKED); |
| } |
| else |
| { |
| // AGC is not supported |
| GetDlgItem(IDC_CHECK_AGC)->EnableWindow(FALSE); |
| } |
| |
| NsModes nsMode(kNsDefault); |
| if (_veApmPtr->GetNsStatus(enable, nsMode) == 0) |
| { |
| button = (CButton*)GetDlgItem(IDC_CHECK_NS); |
| enable ? button->SetCheck(BST_CHECKED) : button->SetCheck(BST_UNCHECKED); |
| } |
| else |
| { |
| // NS is not supported |
| GetDlgItem(IDC_CHECK_NS)->EnableWindow(FALSE); |
| } |
| |
| EcModes ecMode(kEcDefault); |
| if (_veApmPtr->GetEcStatus(enable, ecMode) == 0) |
| { |
| button = (CButton*)GetDlgItem(IDC_CHECK_EC); |
| enable ? button->SetCheck(BST_CHECKED) : button->SetCheck(BST_UNCHECKED); |
| } |
| else |
| { |
| // EC is not supported |
| GetDlgItem(IDC_CHECK_EC)->EnableWindow(FALSE); |
| } |
| |
| // --- First channel section |
| |
| GetDlgItem(IDC_COMBO_IP_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_EDIT_TX_PORT_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_EDIT_RX_PORT_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_COMBO_CODEC_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_LIST_CODEC_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_EDIT_CODEC_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_DELETE_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_START_LISTEN_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_STOP_LISTEN_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_START_PLAYOUT_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_STOP_PLAYOUT_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_START_SEND_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_STOP_SEND_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_EXT_TRANS_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_PLAY_FILE_IN_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_PLAY_FILE_OUT_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_EXT_MEDIA_IN_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_EXT_MEDIA_OUT_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_VAD_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_MUTE_IN_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_SRTP_TX_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_SRTP_RX_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_EXT_ENCRYPTION_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_DTMF_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_CONFERENCE_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_ON_HOLD_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_DELAY_ESTIMATE_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_RXVAD)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_AGC_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_NS_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_FEC)->EnableWindow(FALSE); |
| |
| CComboBox* comboIP(NULL); |
| comboIP = (CComboBox*)GetDlgItem(IDC_COMBO_IP_1); |
| comboIP->AddString(_T("127.0.0.1")); |
| comboIP->SetCurSel(0); |
| |
| SetDlgItemInt(IDC_EDIT_TX_PORT_1, 1111); |
| SetDlgItemInt(IDC_EDIT_RX_PORT_1, 1111); |
| |
| // --- Add supported codecs to the codec combo box |
| |
| CComboBox* comboCodec(NULL); |
| comboCodec = (CComboBox*)GetDlgItem(IDC_COMBO_CODEC_1); |
| comboCodec->ResetContent(); |
| |
| int numCodecs = _veCodecPtr->NumOfCodecs(); |
| for (int idx = 0; idx < numCodecs; idx++) |
| { |
| CodecInst codec; |
| _veCodecPtr->GetCodec(idx, codec); |
| if ((_stricmp(codec.plname, "CNNB") != 0) && |
| (_stricmp(codec.plname, "CNWB") != 0)) |
| { |
| CString strCodec; |
| if (_stricmp(codec.plname, "G7221") == 0) |
| strCodec.Format(_T("%s (%d/%d/%d)"), CharToTchar(codec.plname, 32), codec.pltype, codec.plfreq/1000, codec.rate/1000); |
| else |
| strCodec.Format(_T("%s (%d/%d)"), CharToTchar(codec.plname, 32), codec.pltype, codec.plfreq/1000); |
| comboCodec->AddString(strCodec); |
| } |
| if (idx == 0) |
| { |
| SetDlgItemInt(IDC_EDIT_CODEC_1, codec.pltype); |
| } |
| } |
| comboCodec->SetCurSel(0); |
| |
| CListBox* list = (CListBox*)GetDlgItem(IDC_LIST_CODEC_1); |
| list->AddString(_T("pltype")); |
| list->AddString(_T("plfreq")); |
| list->AddString(_T("pacsize")); |
| list->AddString(_T("channels")); |
| list->AddString(_T("rate")); |
| list->SetCurSel(0); |
| |
| // --- Add available audio devices to the combo boxes |
| |
| CComboBox* comboRecDevice(NULL); |
| CComboBox* comboPlayDevice(NULL); |
| comboRecDevice = (CComboBox*)GetDlgItem(IDC_COMBO_REC_DEVICE); |
| comboPlayDevice = (CComboBox*)GetDlgItem(IDC_COMBO_PLAY_DEVICE); |
| comboRecDevice->ResetContent(); |
| comboPlayDevice->ResetContent(); |
| |
| if (_veHardwarePtr) |
| { |
| int numPlayout(0); |
| int numRecording(0); |
| char nameStr[128]; |
| char guidStr[128]; |
| CString strDevice; |
| AudioLayers audioLayer; |
| |
| _veHardwarePtr->GetAudioDeviceLayer(audioLayer); |
| if (kAudioWindowsWave == audioLayer) |
| { |
| strDevice.FormatMessage(_T("Audio Layer: Windows Wave API")); |
| } |
| else if (kAudioWindowsCore == audioLayer) |
| { |
| strDevice.FormatMessage(_T("Audio Layer: Windows Core API")); |
| } |
| else |
| { |
| strDevice.FormatMessage(_T("Audio Layer: ** UNKNOWN **")); |
| } |
| SetDlgItemText(IDC_EDIT_AUDIO_LAYER, (LPCTSTR)strDevice); |
| |
| _veHardwarePtr->GetNumOfRecordingDevices(numRecording); |
| |
| for (int idx = 0; idx < numRecording; idx++) |
| { |
| _veHardwarePtr->GetRecordingDeviceName(idx, nameStr, guidStr); |
| strDevice.Format(_T("%s"), CharToTchar(nameStr, 128)); |
| comboRecDevice->AddString(strDevice); |
| } |
| // Select default (communication) device in the combo box |
| _veHardwarePtr->GetRecordingDeviceName(-1, nameStr, guidStr); |
| CString tmp = CString(nameStr); |
| int nIndex = comboRecDevice->SelectString(-1, tmp); |
| ASSERT(nIndex != CB_ERR); |
| |
| _veHardwarePtr->GetNumOfPlayoutDevices(numPlayout); |
| |
| for (int idx = 0; idx < numPlayout; idx++) |
| { |
| _veHardwarePtr->GetPlayoutDeviceName(idx, nameStr, guidStr); |
| strDevice.Format(_T("%s"), CharToTchar(nameStr, 128)); |
| comboPlayDevice->AddString(strDevice); |
| } |
| // Select default (communication) device in the combo box |
| _veHardwarePtr->GetPlayoutDeviceName(-1, nameStr, guidStr); |
| nIndex = comboPlayDevice->SelectString(-1, CString(nameStr)); |
| ASSERT(nIndex != CB_ERR); |
| } |
| |
| // --- Second channel section |
| |
| GetDlgItem(IDC_COMBO_IP_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_EDIT_TX_PORT_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_EDIT_RX_PORT_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_COMBO_CODEC_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_DELETE_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_START_LISTEN_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_STOP_LISTEN_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_START_PLAYOUT_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_STOP_PLAYOUT_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_START_SEND_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_STOP_SEND_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_EXT_TRANS_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_PLAY_FILE_IN_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_PLAY_FILE_OUT_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_EXT_MEDIA_IN_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_EXT_MEDIA_OUT_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_VAD_3)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_MUTE_IN_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_SRTP_TX_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_SRTP_RX_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_EXT_ENCRYPTION_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_DTMF_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_CONFERENCE_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_ON_HOLD_2)->EnableWindow(FALSE); |
| |
| comboIP = (CComboBox*)GetDlgItem(IDC_COMBO_IP_2); |
| comboIP->AddString(_T("127.0.0.1")); |
| comboIP->SetCurSel(0); |
| |
| SetDlgItemInt(IDC_EDIT_TX_PORT_2, 2222); |
| SetDlgItemInt(IDC_EDIT_RX_PORT_2, 2222); |
| |
| comboCodec = (CComboBox*)GetDlgItem(IDC_COMBO_CODEC_2); |
| comboCodec->ResetContent(); |
| |
| if (_veCodecPtr) |
| { |
| numCodecs = _veCodecPtr->NumOfCodecs(); |
| for (int idx = 0; idx < numCodecs; idx++) |
| { |
| CodecInst codec; |
| _veCodecPtr->GetCodec(idx, codec); |
| CString strCodec; |
| strCodec.Format(_T("%s (%d/%d)"), CharToTchar(codec.plname, 32), codec.pltype, codec.plfreq/1000); |
| comboCodec->AddString(strCodec); |
| } |
| comboCodec->SetCurSel(0); |
| } |
| |
| // --- Start windows timer |
| |
| SetTimer(0, 1000, NULL); |
| |
| return TRUE; // return TRUE unless you set the focus to a control |
| } |
| |
| void CWinTestDlg::OnSysCommand(UINT nID, LPARAM lParam) |
| { |
| if ((nID & 0xFFF0) == IDM_ABOUTBOX) |
| { |
| CAboutDlg dlgAbout; |
| dlgAbout.DoModal(); |
| } |
| else if (nID == SC_CLOSE) |
| { |
| BOOL ret; |
| int channel(0); |
| channel = GetDlgItemInt(IDC_EDIT_1, &ret); |
| if (ret == TRUE) |
| { |
| _veBasePtr->DeleteChannel(channel); |
| } |
| channel = GetDlgItemInt(IDC_EDIT_2, &ret); |
| if (ret == TRUE) |
| { |
| _veBasePtr->DeleteChannel(channel); |
| } |
| |
| CDialog::OnSysCommand(nID, lParam); |
| } |
| else |
| { |
| CDialog::OnSysCommand(nID, lParam); |
| } |
| |
| } |
| |
| // If you add a minimize button to your dialog, you will need the code below |
| // to draw the icon. For MFC applications using the document/view model, |
| // this is automatically done for you by the framework. |
| |
| void CWinTestDlg::OnPaint() |
| { |
| if (IsIconic()) |
| { |
| CPaintDC dc(this); // device context for painting |
| |
| SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0); |
| |
| // Center icon in client rectangle |
| int cxIcon = GetSystemMetrics(SM_CXICON); |
| int cyIcon = GetSystemMetrics(SM_CYICON); |
| CRect rect; |
| GetClientRect(&rect); |
| int x = (rect.Width() - cxIcon + 1) / 2; |
| int y = (rect.Height() - cyIcon + 1) / 2; |
| |
| // Draw the icon |
| dc.DrawIcon(x, y, m_hIcon); |
| } |
| else |
| { |
| CDialog::OnPaint(); |
| } |
| } |
| |
| // The system calls this function to obtain the cursor to display while the user drags |
| // the minimized window. |
| HCURSOR CWinTestDlg::OnQueryDragIcon() |
| { |
| return static_cast<HCURSOR>(m_hIcon); |
| } |
| |
| |
| void CWinTestDlg::OnBnClickedButtonCreate1() |
| { |
| int channel(0); |
| TEST((channel = _veBasePtr->CreateChannel()) >= 0, _T("CreateChannel(channel=%d)"), channel); |
| if (channel >= 0) |
| { |
| _veRtpRtcpPtr->RegisterRTPObserver(channel, *this); |
| |
| SetDlgItemInt(IDC_EDIT_1, channel); |
| GetDlgItem(IDC_BUTTON_CREATE_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_DELETE_1)->EnableWindow(TRUE); |
| GetDlgItem(IDC_COMBO_IP_1)->EnableWindow(TRUE); |
| GetDlgItem(IDC_EDIT_TX_PORT_1)->EnableWindow(TRUE); |
| GetDlgItem(IDC_EDIT_RX_PORT_1)->EnableWindow(TRUE); |
| GetDlgItem(IDC_COMBO_CODEC_1)->EnableWindow(TRUE); |
| GetDlgItem(IDC_LIST_CODEC_1)->EnableWindow(TRUE); |
| GetDlgItem(IDC_EDIT_CODEC_1)->EnableWindow(TRUE); |
| GetDlgItem(IDC_BUTTON_START_LISTEN_1)->EnableWindow(TRUE); |
| GetDlgItem(IDC_BUTTON_START_PLAYOUT_1)->EnableWindow(TRUE); |
| GetDlgItem(IDC_BUTTON_START_SEND_1)->EnableWindow(TRUE); |
| GetDlgItem(IDC_CHECK_EXT_TRANS_1)->EnableWindow(TRUE); |
| GetDlgItem(IDC_CHECK_PLAY_FILE_IN_1)->EnableWindow(TRUE); |
| GetDlgItem(IDC_CHECK_PLAY_FILE_OUT_1)->EnableWindow(TRUE); |
| GetDlgItem(IDC_CHECK_EXT_MEDIA_IN_1)->EnableWindow(TRUE); |
| GetDlgItem(IDC_CHECK_EXT_MEDIA_OUT_1)->EnableWindow(TRUE); |
| GetDlgItem(IDC_CHECK_VAD_1)->EnableWindow(TRUE); |
| GetDlgItem(IDC_CHECK_MUTE_IN_1)->EnableWindow(TRUE); |
| GetDlgItem(IDC_CHECK_SRTP_TX_1)->EnableWindow(TRUE); |
| GetDlgItem(IDC_CHECK_SRTP_RX_1)->EnableWindow(TRUE); |
| GetDlgItem(IDC_CHECK_EXT_ENCRYPTION_1)->EnableWindow(TRUE); |
| GetDlgItem(IDC_BUTTON_DTMF_1)->EnableWindow(TRUE); |
| GetDlgItem(IDC_CHECK_ON_HOLD_1)->EnableWindow(TRUE); |
| GetDlgItem(IDC_CHECK_DELAY_ESTIMATE_1)->EnableWindow(TRUE); |
| GetDlgItem(IDC_CHECK_RXVAD)->EnableWindow(TRUE); |
| GetDlgItem(IDC_CHECK_AGC_1)->EnableWindow(TRUE); |
| GetDlgItem(IDC_CHECK_NS_1)->EnableWindow(TRUE); |
| GetDlgItem(IDC_CHECK_FEC)->EnableWindow(TRUE); |
| |
| bool enabled(false); |
| bool includeCSRCs(false); |
| |
| // Always set send codec to default codec <=> index 0. |
| CodecInst codec; |
| _veCodecPtr->GetCodec(0, codec); |
| _veCodecPtr->SetSendCodec(channel, codec); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedButtonCreate2() |
| { |
| int channel(0); |
| TEST((channel = _veBasePtr->CreateChannel()) >=0 , _T("CreateChannel(%d)"), channel); |
| if (channel >= 0) |
| { |
| _veRtpRtcpPtr->RegisterRTPObserver(channel, *this); |
| |
| SetDlgItemInt(IDC_EDIT_2, channel); |
| GetDlgItem(IDC_BUTTON_CREATE_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_DELETE_2)->EnableWindow(TRUE); |
| GetDlgItem(IDC_COMBO_IP_2)->EnableWindow(TRUE); |
| GetDlgItem(IDC_EDIT_TX_PORT_2)->EnableWindow(TRUE); |
| GetDlgItem(IDC_EDIT_RX_PORT_2)->EnableWindow(TRUE); |
| GetDlgItem(IDC_COMBO_CODEC_2)->EnableWindow(TRUE); |
| GetDlgItem(IDC_BUTTON_START_LISTEN_2)->EnableWindow(TRUE); |
| GetDlgItem(IDC_BUTTON_START_PLAYOUT_2)->EnableWindow(TRUE); |
| GetDlgItem(IDC_BUTTON_START_SEND_2)->EnableWindow(TRUE); |
| GetDlgItem(IDC_CHECK_EXT_TRANS_2)->EnableWindow(TRUE); |
| GetDlgItem(IDC_CHECK_PLAY_FILE_IN_2)->EnableWindow(TRUE); |
| GetDlgItem(IDC_CHECK_PLAY_FILE_OUT_2)->EnableWindow(TRUE); |
| GetDlgItem(IDC_CHECK_EXT_MEDIA_IN_2)->EnableWindow(TRUE); |
| GetDlgItem(IDC_CHECK_EXT_MEDIA_OUT_2)->EnableWindow(TRUE); |
| GetDlgItem(IDC_CHECK_VAD_3)->EnableWindow(TRUE); |
| GetDlgItem(IDC_CHECK_MUTE_IN_2)->EnableWindow(TRUE); |
| GetDlgItem(IDC_CHECK_SRTP_TX_2)->EnableWindow(TRUE); |
| GetDlgItem(IDC_CHECK_SRTP_RX_2)->EnableWindow(TRUE); |
| GetDlgItem(IDC_CHECK_EXT_ENCRYPTION_2)->EnableWindow(TRUE); |
| GetDlgItem(IDC_BUTTON_DTMF_2)->EnableWindow(TRUE); |
| GetDlgItem(IDC_CHECK_CONFERENCE_2)->EnableWindow(TRUE); |
| GetDlgItem(IDC_CHECK_ON_HOLD_2)->EnableWindow(TRUE); |
| |
| bool enabled(false); |
| bool includeCSRCs(false); |
| |
| |
| // Always set send codec to default codec <=> index 0. |
| CodecInst codec; |
| _veCodecPtr->GetCodec(0, codec); |
| _veCodecPtr->SetSendCodec(channel, codec); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedButtonDelete1() |
| { |
| BOOL ret; |
| int channel = GetDlgItemInt(IDC_EDIT_1, &ret); |
| if (ret == TRUE) |
| { |
| _delayEstimate1 = false; |
| _rxVad = false; |
| _veRtpRtcpPtr->DeRegisterRTPObserver(channel); |
| TEST(_veBasePtr->DeleteChannel(channel) == 0, _T("DeleteChannel(channel=%d)"), channel); |
| SetDlgItemText(IDC_EDIT_1, _T("")); |
| GetDlgItem(IDC_BUTTON_CREATE_1)->EnableWindow(TRUE); |
| GetDlgItem(IDC_BUTTON_DELETE_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_COMBO_IP_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_EDIT_TX_PORT_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_EDIT_RX_PORT_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_COMBO_CODEC_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_LIST_CODEC_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_EDIT_CODEC_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_START_LISTEN_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_START_PLAYOUT_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_START_SEND_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_STOP_LISTEN_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_STOP_PLAYOUT_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_STOP_SEND_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_DTMF_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_EXT_TRANS_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_PLAY_FILE_IN_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_PLAY_FILE_OUT_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_EXT_MEDIA_IN_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_EXT_MEDIA_OUT_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_VAD_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_MUTE_IN_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_SRTP_TX_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_SRTP_RX_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_EXT_ENCRYPTION_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_CONFERENCE_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_ON_HOLD_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_DELAY_ESTIMATE_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_AGC_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_NS_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_RXVAD)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_FEC)->EnableWindow(FALSE); |
| SetDlgItemText(IDC_EDIT_RXVAD, _T("")); |
| GetDlgItem(IDC_EDIT_RXVAD)->EnableWindow(FALSE); |
| CButton* button = (CButton*)GetDlgItem(IDC_CHECK_EXT_TRANS_1); |
| button->SetCheck(BST_UNCHECKED); |
| button = (CButton*)GetDlgItem(IDC_CHECK_PLAY_FILE_IN_1); |
| button->SetCheck(BST_UNCHECKED); |
| button = (CButton*)GetDlgItem(IDC_CHECK_PLAY_FILE_OUT_1); |
| button->SetCheck(BST_UNCHECKED); |
| button = (CButton*)GetDlgItem(IDC_CHECK_EXT_MEDIA_IN_1); |
| button->SetCheck(BST_UNCHECKED); |
| button = (CButton*)GetDlgItem(IDC_CHECK_EXT_MEDIA_OUT_1); |
| button->SetCheck(BST_UNCHECKED); |
| button = (CButton*)GetDlgItem(IDC_CHECK_VAD_1); |
| button->SetCheck(BST_UNCHECKED); |
| button = (CButton*)GetDlgItem(IDC_CHECK_MUTE_IN_1); |
| button->SetCheck(BST_UNCHECKED); |
| button = (CButton*)GetDlgItem(IDC_CHECK_SRTP_TX_1); |
| button->SetCheck(BST_UNCHECKED); |
| button = (CButton*)GetDlgItem(IDC_CHECK_SRTP_RX_1); |
| button->SetCheck(BST_UNCHECKED); |
| button = (CButton*)GetDlgItem(IDC_CHECK_EXT_ENCRYPTION_1); |
| button->SetCheck(BST_UNCHECKED); |
| button = (CButton*)GetDlgItem(IDC_CHECK_CONFERENCE_1); |
| button->SetCheck(BST_UNCHECKED); |
| button = (CButton*)GetDlgItem(IDC_CHECK_ON_HOLD_1); |
| button->SetCheck(BST_UNCHECKED); |
| button = (CButton*)GetDlgItem(IDC_CHECK_DELAY_ESTIMATE_1); |
| button->SetCheck(BST_UNCHECKED); |
| button = (CButton*)GetDlgItem(IDC_CHECK_AGC_1); |
| button->SetCheck(BST_UNCHECKED); |
| button = (CButton*)GetDlgItem(IDC_CHECK_NS_1); |
| button->SetCheck(BST_UNCHECKED); |
| button = (CButton*)GetDlgItem(IDC_CHECK_RXVAD); |
| button->SetCheck(BST_UNCHECKED); |
| button = (CButton*)GetDlgItem(IDC_CHECK_FEC); |
| button->SetCheck(BST_UNCHECKED); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedButtonDelete2() |
| { |
| BOOL ret; |
| int channel = GetDlgItemInt(IDC_EDIT_2, &ret); |
| if (ret == TRUE) |
| { |
| _delayEstimate2 = false; |
| _veRtpRtcpPtr->DeRegisterRTPObserver(channel); |
| TEST(_veBasePtr->DeleteChannel(channel) == 0, _T("DeleteChannel(%d)"), channel); |
| SetDlgItemText(IDC_EDIT_2, _T("")); |
| GetDlgItem(IDC_BUTTON_CREATE_2)->EnableWindow(TRUE); |
| GetDlgItem(IDC_BUTTON_DELETE_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_COMBO_IP_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_EDIT_TX_PORT_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_EDIT_RX_PORT_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_COMBO_CODEC_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_START_LISTEN_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_START_PLAYOUT_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_START_SEND_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_STOP_LISTEN_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_STOP_PLAYOUT_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_STOP_SEND_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_EXT_TRANS_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_PLAY_FILE_IN_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_PLAY_FILE_OUT_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_EXT_MEDIA_IN_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_EXT_MEDIA_OUT_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_MUTE_IN_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_VAD_3)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_SRTP_TX_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_SRTP_RX_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_EXT_ENCRYPTION_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_CONFERENCE_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_DTMF_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_CHECK_ON_HOLD_2)->EnableWindow(FALSE); |
| CButton* button = (CButton*)GetDlgItem(IDC_CHECK_EXT_TRANS_2); |
| button->SetCheck(BST_UNCHECKED); |
| button = (CButton*)GetDlgItem(IDC_CHECK_PLAY_FILE_IN_2); |
| button->SetCheck(BST_UNCHECKED); |
| button = (CButton*)GetDlgItem(IDC_CHECK_PLAY_FILE_OUT_2); |
| button->SetCheck(BST_UNCHECKED); |
| button = (CButton*)GetDlgItem(IDC_CHECK_EXT_MEDIA_IN_2); |
| button->SetCheck(BST_UNCHECKED); |
| button = (CButton*)GetDlgItem(IDC_CHECK_EXT_MEDIA_OUT_2); |
| button->SetCheck(BST_UNCHECKED); |
| button = (CButton*)GetDlgItem(IDC_CHECK_VAD_3); |
| button->SetCheck(BST_UNCHECKED); |
| button = (CButton*)GetDlgItem(IDC_CHECK_MUTE_IN_2); |
| button->SetCheck(BST_UNCHECKED); |
| button = (CButton*)GetDlgItem(IDC_CHECK_SRTP_TX_2); |
| button->SetCheck(BST_UNCHECKED); |
| button = (CButton*)GetDlgItem(IDC_CHECK_SRTP_RX_2); |
| button->SetCheck(BST_UNCHECKED); |
| button = (CButton*)GetDlgItem(IDC_CHECK_EXT_ENCRYPTION_2); |
| button->SetCheck(BST_UNCHECKED); |
| button = (CButton*)GetDlgItem(IDC_CHECK_CONFERENCE_2); |
| button->SetCheck(BST_UNCHECKED); |
| button = (CButton*)GetDlgItem(IDC_CHECK_ON_HOLD_2); |
| button->SetCheck(BST_UNCHECKED); |
| } |
| } |
| |
| void CWinTestDlg::OnCbnSelchangeComboIp1() |
| { |
| int channel = GetDlgItemInt(IDC_EDIT_1); |
| CString str; |
| int port = GetDlgItemInt(IDC_EDIT_TX_PORT_1); |
| CComboBox* comboIP = (CComboBox*)GetDlgItem(IDC_COMBO_IP_1); |
| int n = comboIP->GetLBTextLen(0); |
| comboIP->GetLBText(0, str.GetBuffer(n)); |
| TEST(_veBasePtr->SetSendDestination(channel, port, TcharToChar(str.GetBuffer(n), -1)) == 0, |
| _T("SetSendDestination(channel=%d, port=%d, ip=%s)"), channel, port, str.GetBuffer(n)); |
| str.ReleaseBuffer(); |
| } |
| |
| void CWinTestDlg::OnCbnSelchangeComboIp2() |
| { |
| int channel = GetDlgItemInt(IDC_EDIT_2); |
| CString str; |
| int port = GetDlgItemInt(IDC_EDIT_TX_PORT_2); |
| CComboBox* comboIP = (CComboBox*)GetDlgItem(IDC_COMBO_IP_2); |
| int n = comboIP->GetLBTextLen(0); |
| comboIP->GetLBText(0, str.GetBuffer(n)); |
| TEST(_veBasePtr->SetSendDestination(channel, port, TcharToChar(str.GetBuffer(n), -1)) == 0, |
| _T("SetSendDestination(channel=%d, port=%d, ip=%s)"), channel, port, str.GetBuffer(n)); |
| str.ReleaseBuffer(); |
| } |
| |
| void CWinTestDlg::OnCbnSelchangeComboCodec1() |
| { |
| int channel = GetDlgItemInt(IDC_EDIT_1); |
| |
| CodecInst codec; |
| CComboBox* comboCodec(NULL); |
| comboCodec = (CComboBox*)GetDlgItem(IDC_COMBO_CODEC_1); |
| int index = comboCodec->GetCurSel(); |
| _veCodecPtr->GetCodec(index, codec); |
| if (strncmp(codec.plname, "ISAC", 4) == 0) |
| { |
| // Set iSAC to adaptive mode by default. |
| codec.rate = -1; |
| } |
| TEST(_veCodecPtr->SetSendCodec(channel, codec) == 0, |
| _T("SetSendCodec(channel=%d, plname=%s, pltype=%d, plfreq=%d, rate=%d, pacsize=%d, channels=%d)"), |
| channel, CharToTchar(codec.plname, 32), codec.pltype, codec.plfreq, codec.rate, codec.pacsize, codec.channels); |
| |
| CListBox* list = (CListBox*)GetDlgItem(IDC_LIST_CODEC_1); |
| list->SetCurSel(0); |
| SetDlgItemInt(IDC_EDIT_CODEC_1, codec.pltype); |
| } |
| |
| void CWinTestDlg::OnLbnSelchangeListCodec1() |
| { |
| int channel = GetDlgItemInt(IDC_EDIT_1); |
| |
| CListBox* list = (CListBox*)GetDlgItem(IDC_LIST_CODEC_1); |
| int listIdx = list->GetCurSel(); |
| if (listIdx < 0) |
| return; |
| CString str; |
| list->GetText(listIdx, str); |
| |
| CodecInst codec; |
| _veCodecPtr->GetSendCodec(channel, codec); |
| |
| int value = GetDlgItemInt(IDC_EDIT_CODEC_1); |
| if (str == _T("pltype")) |
| { |
| codec.pltype = value; |
| } |
| else if (str == _T("plfreq")) |
| { |
| codec.plfreq = value; |
| } |
| else if (str == _T("pacsize")) |
| { |
| codec.pacsize = value; |
| } |
| else if (str == _T("channels")) |
| { |
| codec.channels = value; |
| } |
| else if (str == _T("rate")) |
| { |
| codec.rate = value; |
| } |
| TEST(_veCodecPtr->SetSendCodec(channel, codec) == 0, |
| _T("SetSendCodec(channel=%d, plname=%s, pltype=%d, plfreq=%d, rate=%d, pacsize=%d, channels=%d)"), |
| channel, CharToTchar(codec.plname, 32), codec.pltype, codec.plfreq, codec.rate, codec.pacsize, codec.channels); |
| } |
| |
| void CWinTestDlg::OnCbnSelchangeComboCodec2() |
| { |
| int channel = GetDlgItemInt(IDC_EDIT_2); |
| |
| CodecInst codec; |
| CComboBox* comboCodec(NULL); |
| comboCodec = (CComboBox*)GetDlgItem(IDC_COMBO_CODEC_2); |
| int index = comboCodec->GetCurSel(); |
| _veCodecPtr->GetCodec(index, codec); |
| TEST(_veCodecPtr->SetSendCodec(channel, codec) == 0, |
| _T("SetSendCodec(channel=%d, plname=%s, pltype=%d, plfreq=%d, rate=%d, pacsize=%d, channels=%d)"), |
| channel, CharToTchar(codec.plname, 32), codec.pltype, codec.plfreq, codec.rate, codec.pacsize, codec.channels); |
| } |
| |
| void CWinTestDlg::OnBnClickedButtonStartListen1() |
| { |
| int ret1(0); |
| int ret2(0); |
| int channel = GetDlgItemInt(IDC_EDIT_1); |
| int port = GetDlgItemInt(IDC_EDIT_RX_PORT_1); |
| TEST((ret1 = _veBasePtr->SetLocalReceiver(channel, port)) == 0, _T("SetLocalReceiver(channel=%d, port=%d)"), channel, port); |
| TEST((ret2 = _veBasePtr->StartReceive(channel)) == 0, _T("StartReceive(channel=%d)"), channel); |
| if (ret1 == 0 && ret2 == 0) |
| { |
| GetDlgItem(IDC_BUTTON_START_LISTEN_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_STOP_LISTEN_1)->EnableWindow(TRUE); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedButtonStartListen2() |
| { |
| int ret1(0); |
| int ret2(0); |
| int channel = GetDlgItemInt(IDC_EDIT_2); |
| int port = GetDlgItemInt(IDC_EDIT_RX_PORT_2); |
| TEST((ret1 = _veBasePtr->SetLocalReceiver(channel, port)) == 0, _T("SetLocalReceiver(channel=%d, port=%d)"), channel, port); |
| TEST((ret2 = _veBasePtr->StartReceive(channel)) == 0, _T("StartReceive(channel=%d)"), channel); |
| if (ret1 == 0 && ret2 == 0) |
| { |
| GetDlgItem(IDC_BUTTON_START_LISTEN_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_STOP_LISTEN_2)->EnableWindow(TRUE); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedButtonStopListen1() |
| { |
| int ret(0); |
| int channel = GetDlgItemInt(IDC_EDIT_1); |
| TEST((ret = _veBasePtr->StopReceive(channel)) == 0, _T("StopListen(channel=%d)"), channel); |
| if (ret == 0) |
| { |
| GetDlgItem(IDC_BUTTON_START_LISTEN_1)->EnableWindow(TRUE); |
| GetDlgItem(IDC_BUTTON_STOP_LISTEN_1)->EnableWindow(FALSE); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedButtonStopListen2() |
| { |
| int ret(0); |
| int channel = GetDlgItemInt(IDC_EDIT_2); |
| TEST((ret = _veBasePtr->StopReceive(channel)) == 0, _T("StopListen(channel=%d)"), channel); |
| if (ret == 0) |
| { |
| GetDlgItem(IDC_BUTTON_START_LISTEN_2)->EnableWindow(TRUE); |
| GetDlgItem(IDC_BUTTON_STOP_LISTEN_2)->EnableWindow(FALSE); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedButtonStartPlayout1() |
| { |
| int ret(0); |
| int channel = GetDlgItemInt(IDC_EDIT_1); |
| TEST((ret = _veBasePtr->StartPlayout(channel)) == 0, _T("StartPlayout(channel=%d)"), channel); |
| if (ret == 0) |
| { |
| GetDlgItem(IDC_BUTTON_START_PLAYOUT_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_STOP_PLAYOUT_1)->EnableWindow(TRUE); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedButtonStartPlayout2() |
| { |
| int ret(0); |
| int channel = GetDlgItemInt(IDC_EDIT_2); |
| TEST((ret = _veBasePtr->StartPlayout(channel)) == 0, _T("StartPlayout(channel=%d)"), channel); |
| if (ret == 0) |
| { |
| GetDlgItem(IDC_BUTTON_START_PLAYOUT_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_STOP_PLAYOUT_2)->EnableWindow(TRUE); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedButtonStopPlayout1() |
| { |
| int ret(0); |
| int channel = GetDlgItemInt(IDC_EDIT_1); |
| TEST((ret = _veBasePtr->StopPlayout(channel)) == 0, _T("StopPlayout(channel=%d)"), channel); |
| if (ret == 0) |
| { |
| GetDlgItem(IDC_BUTTON_START_PLAYOUT_1)->EnableWindow(TRUE); |
| GetDlgItem(IDC_BUTTON_STOP_PLAYOUT_1)->EnableWindow(FALSE); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedButtonStopPlayout2() |
| { |
| int ret(0); |
| int channel = GetDlgItemInt(IDC_EDIT_2); |
| TEST((ret = _veBasePtr->StopPlayout(channel)) == 0, _T("StopPlayout(channel=%d)")); |
| if (ret == 0) |
| { |
| GetDlgItem(IDC_BUTTON_START_PLAYOUT_2)->EnableWindow(TRUE); |
| GetDlgItem(IDC_BUTTON_STOP_PLAYOUT_2)->EnableWindow(FALSE); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedButtonStartSend1() |
| { |
| UpdateData(TRUE); // update IP address |
| |
| int ret(0); |
| int channel = GetDlgItemInt(IDC_EDIT_1); |
| if (!_externalTransport) |
| { |
| CString str; |
| int port = GetDlgItemInt(IDC_EDIT_TX_PORT_1); |
| TEST(_veBasePtr->SetSendDestination(channel, port, TcharToChar(_strComboIp1.GetBuffer(7), -1)) == 0, |
| _T("SetSendDestination(channel=%d, port=%d, ip=%s)"), channel, port, _strComboIp1.GetBuffer(7)); |
| str.ReleaseBuffer(); |
| } |
| |
| //_veVideoSyncPtr->SetInitTimestamp(0,0); |
| // OnCbnSelchangeComboCodec1(); |
| |
| TEST((ret = _veBasePtr->StartSend(channel)) == 0, _T("StartSend(channel=%d)"), channel); |
| if (ret == 0) |
| { |
| GetDlgItem(IDC_BUTTON_START_SEND_1)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_STOP_SEND_1)->EnableWindow(TRUE); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedButtonStartSend2() |
| { |
| UpdateData(TRUE); // update IP address |
| |
| int ret(0); |
| int channel = GetDlgItemInt(IDC_EDIT_2); |
| if (!_externalTransport) |
| { |
| CString str; |
| int port = GetDlgItemInt(IDC_EDIT_TX_PORT_2); |
| TEST(_veBasePtr->SetSendDestination(channel, port, TcharToChar(_strComboIp2.GetBuffer(7), -1)) == 0, |
| _T("SetSendDestination(channel=%d, port=%d, ip=%s)"), channel, port, _strComboIp2.GetBuffer(7)); |
| str.ReleaseBuffer(); |
| } |
| |
| // OnCbnSelchangeComboCodec2(); |
| |
| TEST((ret = _veBasePtr->StartSend(channel)) == 0, _T("StartSend(channel=%d)"), channel); |
| if (ret == 0) |
| { |
| GetDlgItem(IDC_BUTTON_START_SEND_2)->EnableWindow(FALSE); |
| GetDlgItem(IDC_BUTTON_STOP_SEND_2)->EnableWindow(TRUE); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedButtonStopSend1() |
| { |
| int ret(0); |
| int channel = GetDlgItemInt(IDC_EDIT_1); |
| TEST((ret = _veBasePtr->StopSend(channel)) == 0, _T("StopSend(channel=%d)"), channel); |
| if (ret == 0) |
| { |
| GetDlgItem(IDC_BUTTON_START_SEND_1)->EnableWindow(TRUE); |
| GetDlgItem(IDC_BUTTON_STOP_SEND_1)->EnableWindow(FALSE); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedButtonStopSend2() |
| { |
| int ret(0); |
| int channel = GetDlgItemInt(IDC_EDIT_2); |
| TEST((ret = _veBasePtr->StopSend(channel)) == 0, _T("StopSend(channel=%d)"), channel); |
| if (ret == 0) |
| { |
| GetDlgItem(IDC_BUTTON_START_SEND_2)->EnableWindow(TRUE); |
| GetDlgItem(IDC_BUTTON_STOP_SEND_2)->EnableWindow(FALSE); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckExtTrans1() |
| { |
| int ret(0); |
| int channel = GetDlgItemInt(IDC_EDIT_1); |
| CButton* button = (CButton*)GetDlgItem(IDC_CHECK_EXT_TRANS_1); |
| int check = button->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| if (enable) |
| { |
| TEST((ret = _veNetworkPtr->RegisterExternalTransport(channel, *_transportPtr)) == 0, |
| _T("RegisterExternalTransport(channel=%d, transport=0x%x)"), channel, _transportPtr); |
| } |
| else |
| { |
| TEST((ret = _veNetworkPtr->DeRegisterExternalTransport(channel)) == 0, |
| _T("DeRegisterExternalTransport(channel=%d)"), channel); |
| } |
| if (ret == 0) |
| { |
| _externalTransport = enable; |
| } |
| else |
| { |
| // restore inital state since API call failed |
| button->SetCheck((check == BST_CHECKED) ? BST_UNCHECKED : BST_CHECKED); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckExtTrans2() |
| { |
| int ret(0); |
| int channel = GetDlgItemInt(IDC_EDIT_2); |
| CButton* button = (CButton*)GetDlgItem(IDC_CHECK_EXT_TRANS_2); |
| int check = button->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| if (enable) |
| { |
| TEST((ret = _veNetworkPtr->RegisterExternalTransport(channel, *_transportPtr)) == 0, |
| _T("RegisterExternalTransport(channel=%d, transport=0x%x)"), channel, _transportPtr); |
| } |
| else |
| { |
| TEST((ret = _veNetworkPtr->DeRegisterExternalTransport(channel)) == 0, |
| _T("DeRegisterExternalTransport(channel=%d)"), channel); |
| } |
| if (ret == 0) |
| { |
| _externalTransport = enable; |
| } |
| else |
| { |
| // restore inital state since API call failed |
| button->SetCheck((check == BST_CHECKED) ? BST_UNCHECKED : BST_CHECKED); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckPlayFileIn1() |
| { |
| // File path is relative to the location of 'voice_engine.gyp'. |
| const char micFile[] = "../test/data/voice_engine/audio_short16.pcm"; |
| |
| int ret(0); |
| int channel = GetDlgItemInt(IDC_EDIT_1); |
| CButton* button = (CButton*)GetDlgItem(IDC_CHECK_PLAY_FILE_IN_1); |
| int check = button->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| if (enable) |
| { |
| bool mix; |
| const bool loop(true); |
| const FileFormats format = kFileFormatPcm16kHzFile; |
| const float scale(1.0); |
| |
| (_checkPlayFileIn1 %2 == 0) ? mix = true : mix = false; |
| TEST((ret = _veFilePtr->StartPlayingFileAsMicrophone(channel, micFile, loop, mix, format, scale) == 0), |
| _T("StartPlayingFileAsMicrophone(channel=%d, file=%s, loop=%d, mix=%d, format=%d, scale=%2.1f)"), |
| channel, CharToTchar(micFile, -1), loop, mix, format, scale); |
| _checkPlayFileIn1++; |
| } |
| else |
| { |
| TEST((ret = _veFilePtr->StopPlayingFileAsMicrophone(channel) == 0), |
| _T("StopPlayingFileAsMicrophone(channel=%d)"), channel); |
| } |
| if (ret == -1) |
| { |
| // restore inital state since API call failed |
| button->SetCheck((check == BST_CHECKED) ? BST_UNCHECKED : BST_CHECKED); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckPlayFileIn2() |
| { |
| // File path is relative to the location of 'voice_engine.gyp'. |
| const char micFile[] = "../test/data/voice_engine/audio_long16.pcm"; |
| |
| int ret(0); |
| int channel = GetDlgItemInt(IDC_EDIT_2); |
| CButton* button = (CButton*)GetDlgItem(IDC_CHECK_PLAY_FILE_IN_2); |
| int check = button->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| if (enable) |
| { |
| bool mix; |
| const bool loop(true); |
| const FileFormats format = kFileFormatPcm16kHzFile; |
| const float scale(1.0); |
| |
| (_checkPlayFileIn2 %2 == 0) ? mix = true : mix = false; |
| TEST((ret = _veFilePtr->StartPlayingFileAsMicrophone(channel, micFile, loop, mix, format, scale) == 0), |
| _T("StartPlayingFileAsMicrophone(channel=%d, file=%s, loop=%d, mix=%d, format=%d, scale=%2.1f)"), |
| channel, CharToTchar(micFile, -1), loop, mix, format, scale); |
| _checkPlayFileIn2++; |
| } |
| else |
| { |
| TEST((ret = _veFilePtr->StopPlayingFileAsMicrophone(channel) == 0), |
| _T("StopPlayingFileAsMicrophone(channel=%d)"), channel); |
| } |
| if (ret == -1) |
| { |
| // restore inital state since API call failed |
| button->SetCheck((check == BST_CHECKED) ? BST_UNCHECKED : BST_CHECKED); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckPlayFileOut1() |
| { |
| const FileFormats formats[8] = {{kFileFormatPcm16kHzFile}, |
| {kFileFormatWavFile}, |
| {kFileFormatWavFile}, |
| {kFileFormatWavFile}, |
| {kFileFormatWavFile}, |
| {kFileFormatWavFile}, |
| {kFileFormatWavFile}, |
| {kFileFormatWavFile}}; |
| // File path is relative to the location of 'voice_engine.gyp'. |
| const char spkrFiles[8][64] = {{"../../test/data/voice_engine/audio_short16.pcm"}, |
| {"../../test/data/voice_engine/audio_tiny8.wav"}, |
| {"../../test/data/voice_engine/audio_tiny11.wav"}, |
| {"../../test/data/voice_engine/audio_tiny16.wav"}, |
| {"../../test/data/voice_engine/audio_tiny22.wav"}, |
| {"../../test/data/voice_engine/audio_tiny32.wav"}, |
| {"../../test/data/voice_engine/audio_tiny44.wav"}, |
| {"../../test/data/voice_engine/audio_tiny48.wav"}}; |
| int ret(0); |
| int channel = GetDlgItemInt(IDC_EDIT_1); |
| CButton* button = (CButton*)GetDlgItem(IDC_CHECK_PLAY_FILE_OUT_1); |
| int check = button->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| if (enable) |
| { |
| const bool loop(true); |
| const float volumeScaling(1.0); |
| const int startPointMs(0); |
| const int stopPointMs(0); |
| const FileFormats format = formats[_checkPlayFileOut1 % 8]; |
| const char* spkrFile = spkrFiles[_checkPlayFileOut1 % 8]; |
| |
| CString str; |
| if (_checkPlayFileOut1 % 8 == 0) |
| { |
| str = _T("kFileFormatPcm16kHzFile"); |
| } |
| else |
| { |
| str = _T("kFileFormatWavFile"); |
| } |
| // (_checkPlayFileOut1 %2 == 0) ? mix = true : mix = false; |
| TEST((ret = _veFilePtr->StartPlayingFileLocally(channel, spkrFile, loop, format, volumeScaling, startPointMs,stopPointMs) == 0), |
| _T("StartPlayingFileLocally(channel=%d, file=%s, loop=%d, format=%s, scale=%2.1f, start=%d, stop=%d)"), |
| channel, CharToTchar(spkrFile, -1), loop, str, volumeScaling, startPointMs, stopPointMs); |
| _checkPlayFileOut1++; |
| } |
| else |
| { |
| TEST((ret = _veFilePtr->StopPlayingFileLocally(channel) == 0), |
| _T("StopPlayingFileLocally(channel=%d)"), channel); |
| } |
| if (ret == -1) |
| { |
| // restore inital state since API call failed |
| button->SetCheck((check == BST_CHECKED) ? BST_UNCHECKED : BST_CHECKED); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckPlayFileOut2() |
| { |
| // File path is relative to the location of 'voice_engine.gyp'. |
| const char spkrFile[] = "../test/data/voice_engine/audio_long16.pcm"; |
| |
| int ret(0); |
| int channel = GetDlgItemInt(IDC_EDIT_2); |
| CButton* button = (CButton*)GetDlgItem(IDC_CHECK_PLAY_FILE_OUT_2); |
| int check = button->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| if (enable) |
| { |
| const bool loop(true); |
| const FileFormats format = kFileFormatPcm16kHzFile; |
| const float volumeScaling(1.0); |
| const int startPointMs(0); |
| const int stopPointMs(0); |
| |
| // (_checkPlayFileOut2 %2 == 0) ? mix = true : mix = false; |
| TEST((ret = _veFilePtr->StartPlayingFileLocally(channel, spkrFile, loop, format, volumeScaling, startPointMs,stopPointMs) == 0), |
| _T("StartPlayingFileLocally(channel=%d, file=%s, loop=%d, format=%d, scale=%2.1f, start=%d, stop=%d)"), |
| channel, CharToTchar(spkrFile, -1), loop, format, volumeScaling, startPointMs, stopPointMs); |
| // _checkPlayFileIn2++; |
| } |
| else |
| { |
| TEST((ret = _veFilePtr->StopPlayingFileLocally(channel) == 0), |
| _T("StopPlayingFileLocally(channel=%d)"), channel); |
| } |
| if (ret == -1) |
| { |
| // restore inital state since API call failed |
| button->SetCheck((check == BST_CHECKED) ? BST_UNCHECKED : BST_CHECKED); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckExtMediaIn1() |
| { |
| int ret(0); |
| int channel = GetDlgItemInt(IDC_EDIT_1); |
| CButton* buttonExtTrans = (CButton*)GetDlgItem(IDC_CHECK_EXT_MEDIA_IN_1); |
| int check = buttonExtTrans->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| if (enable) |
| { |
| TEST(_veExternalMediaPtr->RegisterExternalMediaProcessing(channel, kRecordingPerChannel, *_externalMediaPtr) == 0, |
| _T("RegisterExternalMediaProcessing(channel=%d, kRecordingPerChannel, processObject=0x%x)"), channel, _externalMediaPtr); |
| } |
| else |
| { |
| TEST(_veExternalMediaPtr->DeRegisterExternalMediaProcessing(channel, kRecordingPerChannel) == 0, |
| _T("DeRegisterExternalMediaProcessing(channel=%d, kRecordingPerChannel)"), channel); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckExtMediaIn2() |
| { |
| int ret(0); |
| int channel = GetDlgItemInt(IDC_EDIT_2); |
| CButton* buttonExtTrans = (CButton*)GetDlgItem(IDC_CHECK_EXT_MEDIA_IN_2); |
| int check = buttonExtTrans->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| if (enable) |
| { |
| TEST(_veExternalMediaPtr->RegisterExternalMediaProcessing(channel, kRecordingPerChannel, *_externalMediaPtr) == 0, |
| _T("RegisterExternalMediaProcessing(channel=%d, kRecordingPerChannel, processObject=0x%x)"), channel, _externalMediaPtr); |
| } |
| else |
| { |
| TEST(_veExternalMediaPtr->DeRegisterExternalMediaProcessing(channel, kRecordingPerChannel) == 0, |
| _T("DeRegisterExternalMediaProcessing(channel=%d, kRecordingPerChannel)"), channel); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckExtMediaOut1() |
| { |
| int ret(0); |
| int channel = GetDlgItemInt(IDC_EDIT_1); |
| CButton* buttonExtTrans = (CButton*)GetDlgItem(IDC_CHECK_EXT_MEDIA_OUT_1); |
| int check = buttonExtTrans->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| if (enable) |
| { |
| TEST(_veExternalMediaPtr->RegisterExternalMediaProcessing(channel, kPlaybackPerChannel, *_externalMediaPtr) == 0, |
| _T("RegisterExternalMediaProcessing(channel=%d, kPlaybackPerChannel, processObject=0x%x)"), channel, _externalMediaPtr); |
| } |
| else |
| { |
| TEST(_veExternalMediaPtr->DeRegisterExternalMediaProcessing(channel, kPlaybackPerChannel) == 0, |
| _T("DeRegisterExternalMediaProcessing(channel=%d, kPlaybackPerChannel)"), channel); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckExtMediaOut2() |
| { |
| int ret(0); |
| int channel = GetDlgItemInt(IDC_EDIT_2); |
| CButton* buttonExtTrans = (CButton*)GetDlgItem(IDC_CHECK_EXT_MEDIA_OUT_2); |
| int check = buttonExtTrans->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| if (enable) |
| { |
| TEST(_veExternalMediaPtr->RegisterExternalMediaProcessing(channel, kPlaybackPerChannel, *_externalMediaPtr) == 0, |
| _T("RegisterExternalMediaProcessing(channel=%d, kPlaybackPerChannel, processObject=0x%x)"), channel, _externalMediaPtr); |
| } |
| else |
| { |
| TEST(_veExternalMediaPtr->DeRegisterExternalMediaProcessing(channel, kPlaybackPerChannel) == 0, |
| _T("DeRegisterExternalMediaProcessing(channel=%d, kPlaybackPerChannel)"), channel); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckVad1() |
| { |
| int ret(0); |
| int channel = GetDlgItemInt(IDC_EDIT_1); |
| CButton* button = (CButton*)GetDlgItem(IDC_CHECK_VAD_1); |
| int check = button->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| if (enable) |
| { |
| CString str; |
| VadModes mode(kVadConventional); |
| if (_checkVAD1 % 4 == 0) |
| { |
| mode = kVadConventional; |
| str = _T("kVadConventional"); |
| } |
| else if (_checkVAD1 % 4 == 1) |
| { |
| mode = kVadAggressiveLow; |
| str = _T("kVadAggressiveLow"); |
| } |
| else if (_checkVAD1 % 4 == 2) |
| { |
| mode = kVadAggressiveMid; |
| str = _T("kVadAggressiveMid"); |
| } |
| else if (_checkVAD1 % 4 == 3) |
| { |
| mode = kVadAggressiveHigh; |
| str = _T("kVadAggressiveHigh"); |
| } |
| const bool disableDTX(false); |
| TEST((ret = _veCodecPtr->SetVADStatus(channel, true, mode, disableDTX) == 0), |
| _T("SetVADStatus(channel=%d, enable=%d, mode=%s, disableDTX=%d)"), channel, enable, str, disableDTX); |
| _checkVAD1++; |
| } |
| else |
| { |
| TEST((ret = _veCodecPtr->SetVADStatus(channel, false)) == 0, _T("SetVADStatus(channel=%d, enable=%d)"), channel, false); |
| } |
| if (ret == -1) |
| { |
| // restore inital state since API call failed |
| button->SetCheck((check == BST_CHECKED) ? BST_UNCHECKED : BST_CHECKED); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckVad2() |
| { |
| int ret(0); |
| int channel = GetDlgItemInt(IDC_EDIT_2); |
| CButton* button = (CButton*)GetDlgItem(IDC_CHECK_VAD_2); |
| int check = button->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| if (enable) |
| { |
| CString str; |
| VadModes mode(kVadConventional); |
| if (_checkVAD2 % 4 == 0) |
| { |
| mode = kVadConventional; |
| str = _T("kVadConventional"); |
| } |
| else if (_checkVAD2 % 4 == 1) |
| { |
| mode = kVadAggressiveLow; |
| str = _T("kVadAggressiveLow"); |
| } |
| else if (_checkVAD2 % 4 == 2) |
| { |
| mode = kVadAggressiveMid; |
| str = _T("kVadAggressiveMid"); |
| } |
| else if (_checkVAD2 % 4 == 3) |
| { |
| mode = kVadAggressiveHigh; |
| str = _T("kVadAggressiveHigh"); |
| } |
| const bool disableDTX(false); |
| TEST((ret = _veCodecPtr->SetVADStatus(channel, true, mode, disableDTX)) == 0, |
| _T("SetVADStatus(channel=%d, enable=%d, mode=%s, disableDTX=%d)"), channel, enable, str, disableDTX); |
| _checkVAD2++; |
| } |
| else |
| { |
| TEST((ret = _veCodecPtr->SetVADStatus(channel, false) == 0), _T("SetVADStatus(channel=%d, enable=%d)"), channel, false); |
| } |
| if (ret == -1) |
| { |
| // restore inital state since API call failed |
| button->SetCheck((check == BST_CHECKED) ? BST_UNCHECKED : BST_CHECKED); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckMuteIn1() |
| { |
| int channel = GetDlgItemInt(IDC_EDIT_1); |
| CButton* buttonMute = (CButton*)GetDlgItem(IDC_CHECK_MUTE_IN_1); |
| int check = buttonMute->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| TEST(_veVolumeControlPtr->SetInputMute(channel, enable) == 0, |
| _T("SetInputMute(channel=%d, enable=%d)"), channel, enable); |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckMuteIn2() |
| { |
| int channel = GetDlgItemInt(IDC_EDIT_2); |
| CButton* buttonMute = (CButton*)GetDlgItem(IDC_CHECK_MUTE_IN_2); |
| int check = buttonMute->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| TEST(_veVolumeControlPtr->SetInputMute(channel, enable) == 0, |
| _T("SetInputMute(channel=%d, enable=%d)"), channel, enable); |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckSrtpTx1() |
| { |
| int ret(0); |
| int channel = GetDlgItemInt(IDC_EDIT_1); |
| CButton* button = (CButton*)GetDlgItem(IDC_CHECK_SRTP_TX_1); |
| int check = button->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| bool useForRTCP = false; |
| if (enable) |
| { |
| (_checkSrtpTx1++ %2 == 0) ? useForRTCP = false : useForRTCP = true; |
| TEST((ret = _veEncryptionPtr->EnableSRTPSend(channel, |
| kCipherAes128CounterMode, 30, kAuthHmacSha1, 20, 4, kEncryptionAndAuthentication, key, useForRTCP)) == 0, |
| _T("EnableSRTPSend(channel=%d, kCipherAes128CounterMode, 30, kAuthHmacSha1, 20, 4, kEncryptionAndAuthentication, key, useForRTCP=%d)"), |
| channel, useForRTCP); |
| } |
| else |
| { |
| TEST((ret = _veEncryptionPtr->DisableSRTPSend(channel) == 0), _T("DisableSRTPSend(channel=%d)"), channel); |
| } |
| if (ret == -1) |
| { |
| // restore inital state since API call failed |
| button->SetCheck((check == BST_CHECKED) ? BST_UNCHECKED : BST_CHECKED); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckSrtpTx2() |
| { |
| int ret(0); |
| int channel = GetDlgItemInt(IDC_EDIT_2); |
| CButton* button = (CButton*)GetDlgItem(IDC_CHECK_SRTP_TX_2); |
| int check = button->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| bool useForRTCP = false; |
| if (enable) |
| { |
| (_checkSrtpTx2++ %2 == 0) ? useForRTCP = false : useForRTCP = true; |
| TEST((ret = _veEncryptionPtr->EnableSRTPSend(channel, |
| kCipherAes128CounterMode, 30, kAuthHmacSha1, 20, 4, kEncryptionAndAuthentication, key, useForRTCP)) == 0, |
| _T("EnableSRTPSend(channel=%d, kCipherAes128CounterMode, 30, kAuthHmacSha1, 20, 4, kEncryptionAndAuthentication, key, useForRTCP=%d)"), |
| channel, useForRTCP); |
| } |
| else |
| { |
| TEST((ret = _veEncryptionPtr->DisableSRTPSend(channel) == 0), _T("DisableSRTPSend(channel=%d)"), channel); |
| } |
| if (ret == -1) |
| { |
| // restore inital state since API call failed |
| button->SetCheck((check == BST_CHECKED) ? BST_UNCHECKED : BST_CHECKED); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckSrtpRx1() |
| { |
| int ret(0); |
| int channel = GetDlgItemInt(IDC_EDIT_1); |
| CButton* button = (CButton*)GetDlgItem(IDC_CHECK_SRTP_RX_1); |
| int check = button->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| bool useForRTCP(false); |
| if (enable) |
| { |
| (_checkSrtpRx1++ %2 == 0) ? useForRTCP = false : useForRTCP = true; |
| TEST((ret = _veEncryptionPtr->EnableSRTPReceive(channel, |
| kCipherAes128CounterMode, 30, kAuthHmacSha1, 20, 4, kEncryptionAndAuthentication, key, useForRTCP)) == 0, |
| _T("EnableSRTPReceive(channel=%d, kCipherAes128CounterMode, 30, kAuthHmacSha1, 20, 4, kEncryptionAndAuthentication, key, useForRTCP=%d)"), |
| channel, useForRTCP); |
| } |
| else |
| { |
| TEST((ret = _veEncryptionPtr->DisableSRTPReceive(channel) == 0), _T("DisableSRTPReceive(channel=%d)"), channel); |
| } |
| if (ret == -1) |
| { |
| // restore inital state since API call failed |
| button->SetCheck((check == BST_CHECKED) ? BST_UNCHECKED : BST_CHECKED); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckSrtpRx2() |
| { |
| int ret(0); |
| int channel = GetDlgItemInt(IDC_EDIT_2); |
| CButton* button = (CButton*)GetDlgItem(IDC_CHECK_SRTP_RX_2); |
| int check = button->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| bool useForRTCP(false); |
| if (enable) |
| { |
| (_checkSrtpRx2++ %2 == 0) ? useForRTCP = false : useForRTCP = true; |
| TEST((ret = _veEncryptionPtr->EnableSRTPReceive(channel, |
| kCipherAes128CounterMode, 30, kAuthHmacSha1, 20, 4, kEncryptionAndAuthentication, key, useForRTCP)) == 0, |
| _T("EnableSRTPReceive(channel=%d, kCipherAes128CounterMode, 30, kAuthHmacSha1, 20, 4, kEncryptionAndAuthentication, key, useForRTCP=%d)"), |
| channel, useForRTCP); |
| } |
| else |
| { |
| TEST((ret = _veEncryptionPtr->DisableSRTPReceive(channel)) == 0, _T("DisableSRTPReceive(channel=%d)"), channel); |
| } |
| if (ret == -1) |
| { |
| // restore inital state since API call failed |
| button->SetCheck((check == BST_CHECKED) ? BST_UNCHECKED : BST_CHECKED); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckExtEncryption1() |
| { |
| int ret(0); |
| int channel = GetDlgItemInt(IDC_EDIT_1); |
| CButton* button = (CButton*)GetDlgItem(IDC_CHECK_EXT_ENCRYPTION_1); |
| int check = button->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| if (enable) |
| { |
| TEST((ret = _veEncryptionPtr->RegisterExternalEncryption(channel, *_encryptionPtr)) == 0, |
| _T("RegisterExternalEncryption(channel=%d, encryption=0x%x)"), channel, _encryptionPtr); |
| } |
| else |
| { |
| TEST((ret = _veEncryptionPtr->DeRegisterExternalEncryption(channel)) == 0, |
| _T("DeRegisterExternalEncryption(channel=%d)"), channel); |
| } |
| if (ret == -1) |
| { |
| // restore inital state since API call failed |
| button->SetCheck((check == BST_CHECKED) ? BST_UNCHECKED : BST_CHECKED); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckExtEncryption2() |
| { |
| int ret(0); |
| int channel = GetDlgItemInt(IDC_EDIT_2); |
| CButton* button = (CButton*)GetDlgItem(IDC_CHECK_EXT_ENCRYPTION_2); |
| int check = button->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| if (enable) |
| { |
| TEST((ret = _veEncryptionPtr->RegisterExternalEncryption(channel, *_encryptionPtr)) == 0, |
| _T("RegisterExternalEncryption(channel=%d, encryption=0x%x)"), channel, _encryptionPtr); |
| } |
| else |
| { |
| TEST((ret = _veEncryptionPtr->DeRegisterExternalEncryption(channel)) == 0, |
| _T("DeRegisterExternalEncryption(channel=%d)"), channel); |
| } |
| if (ret == -1) |
| { |
| // restore inital state since API call failed |
| button->SetCheck((check == BST_CHECKED) ? BST_UNCHECKED : BST_CHECKED); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedButtonDtmf1() |
| { |
| int channel = GetDlgItemInt(IDC_EDIT_1); |
| CTelephonyEvent dlgTelephoneEvent(_vePtr, channel, this); |
| dlgTelephoneEvent.DoModal(); |
| } |
| |
| void CWinTestDlg::OnBnClickedButtonDtmf2() |
| { |
| int channel = GetDlgItemInt(IDC_EDIT_2); |
| CTelephonyEvent dlgTelephoneEvent(_vePtr, channel, this); |
| dlgTelephoneEvent.DoModal(); |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckConference1() |
| { |
| // Not supported yet |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckConference2() |
| { |
| // Not supported yet |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckOnHold1() |
| { |
| SHORT shiftKeyIsPressed = ::GetAsyncKeyState(VK_SHIFT); |
| |
| CString str; |
| int channel = GetDlgItemInt(IDC_EDIT_1); |
| CButton* button = (CButton*)GetDlgItem(IDC_CHECK_ON_HOLD_1); |
| int check = button->GetCheck(); |
| |
| if (shiftKeyIsPressed) |
| { |
| bool enabled(false); |
| OnHoldModes mode(kHoldSendAndPlay); |
| TEST(_veBasePtr->GetOnHoldStatus(channel, enabled, mode) == 0, |
| _T("GetOnHoldStatus(channel=%d, enabled=?, mode=?)"), channel); |
| button->SetCheck((check == BST_CHECKED) ? BST_UNCHECKED : BST_CHECKED); |
| |
| switch (mode) |
| { |
| case kHoldSendAndPlay: |
| str = _T("kHoldSendAndPlay"); |
| break; |
| case kHoldSendOnly: |
| str = _T("kHoldSendOnly"); |
| break; |
| case kHoldPlayOnly: |
| str = _T("kHoldPlayOnly"); |
| break; |
| default: |
| break; |
| } |
| PRINT_GET_RESULT(_T("enabled=%d, mode=%s"), enabled, str); |
| return; |
| } |
| |
| int ret(0); |
| const bool enable = (check == BST_CHECKED); |
| if (enable) |
| { |
| OnHoldModes mode(kHoldSendAndPlay); |
| if (_checkOnHold1 % 3 == 0) |
| { |
| mode = kHoldSendAndPlay; |
| str = _T("kHoldSendAndPlay"); |
| } |
| else if (_checkOnHold1 % 3 == 1) |
| { |
| mode = kHoldSendOnly; |
| str = _T("kHoldSendOnly"); |
| } |
| else if (_checkOnHold1 % 3 == 2) |
| { |
| mode = kHoldPlayOnly; |
| str = _T("kHoldPlayOnly"); |
| } |
| TEST((ret = _veBasePtr->SetOnHoldStatus(channel, enable, mode)) == 0, |
| _T("SetOnHoldStatus(channel=%d, enable=%d, mode=%s)"), channel, enable, str); |
| _checkOnHold1++; |
| } |
| else |
| { |
| TEST((ret = _veBasePtr->SetOnHoldStatus(channel, enable)) == 0, |
| _T("SetOnHoldStatus(channel=%d, enable=%d)"), channel, enable); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckOnHold2() |
| { |
| int ret(0); |
| int channel = GetDlgItemInt(IDC_EDIT_2); |
| CButton* button = (CButton*)GetDlgItem(IDC_CHECK_ON_HOLD_2); |
| int check = button->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| if (enable) |
| { |
| CString str; |
| OnHoldModes mode(kHoldSendAndPlay); |
| if (_checkOnHold1 % 3 == 0) |
| { |
| mode = kHoldSendAndPlay; |
| str = _T("kHoldSendAndPlay"); |
| } |
| else if (_checkOnHold1 % 3 == 1) |
| { |
| mode = kHoldSendOnly; |
| str = _T("kHoldSendOnly"); |
| } |
| else if (_checkOnHold1 % 3 == 2) |
| { |
| mode = kHoldPlayOnly; |
| str = _T("kHoldPlayOnly"); |
| } |
| TEST((ret = _veBasePtr->SetOnHoldStatus(channel, enable, mode)) == 0, |
| _T("SetOnHoldStatus(channel=%d, enable=%d, mode=%s)"), channel, enable, str); |
| _checkOnHold1++; |
| } |
| else |
| { |
| TEST((ret = _veBasePtr->SetOnHoldStatus(channel, enable)) == 0, |
| _T("SetOnHoldStatus(channel=%d, enable=%d)"), channel, enable); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckDelayEstimate1() |
| { |
| int channel = GetDlgItemInt(IDC_EDIT_1); |
| CButton* button = (CButton*)GetDlgItem(IDC_CHECK_DELAY_ESTIMATE_1); |
| int check = button->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| |
| if (enable) |
| { |
| _delayEstimate1 = true; |
| SetDlgItemInt(IDC_EDIT_DELAY_ESTIMATE_1, 0); |
| } |
| else |
| { |
| _delayEstimate1 = false; |
| SetDlgItemText(IDC_EDIT_DELAY_ESTIMATE_1, _T("")); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckRxvad() |
| { |
| int channel = GetDlgItemInt(IDC_EDIT_1); |
| CButton* button = (CButton*)GetDlgItem(IDC_CHECK_RXVAD); |
| int check = button->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| |
| if (enable) |
| { |
| _rxVad = true; |
| _veApmPtr->RegisterRxVadObserver(channel, *_rxVadObserverPtr); |
| SetDlgItemInt(IDC_EDIT_RXVAD, 0); |
| } |
| else |
| { |
| _rxVad = false; |
| _veApmPtr->DeRegisterRxVadObserver(channel); |
| SetDlgItemText(IDC_EDIT_RXVAD, _T("")); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckAgc1() |
| { |
| SHORT shiftKeyIsPressed = ::GetAsyncKeyState(VK_SHIFT); |
| |
| CString str; |
| int channel = GetDlgItemInt(IDC_EDIT_1); |
| CButton* button = (CButton*)GetDlgItem(IDC_CHECK_AGC_1); |
| int check = button->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| |
| if (shiftKeyIsPressed) |
| { |
| bool enabled(false); |
| AgcModes mode(kAgcAdaptiveDigital); |
| TEST(_veApmPtr->GetRxAgcStatus(channel, enabled, mode) == 0, |
| _T("GetRxAgcStatus(channel=%d, enabled=?, mode=?)"), channel); |
| button->SetCheck((check == BST_CHECKED) ? BST_UNCHECKED : BST_CHECKED); |
| |
| switch (mode) |
| { |
| case kAgcAdaptiveAnalog: |
| str = _T("kAgcAdaptiveAnalog"); |
| break; |
| case kAgcAdaptiveDigital: |
| str = _T("kAgcAdaptiveDigital"); |
| break; |
| case kAgcFixedDigital: |
| str = _T("kAgcFixedDigital"); |
| break; |
| default: |
| break; |
| } |
| PRINT_GET_RESULT(_T("enabled=%d, mode=%s"), enabled, str); |
| return; |
| } |
| |
| if (enable) |
| { |
| CString str; |
| AgcModes mode(kAgcDefault); |
| if (_checkAGC1 % 3 == 0) |
| { |
| mode = kAgcDefault; |
| str = _T("kAgcDefault"); |
| } |
| else if (_checkAGC1 % 3 == 1) |
| { |
| mode = kAgcAdaptiveDigital; |
| str = _T("kAgcAdaptiveDigital"); |
| } |
| else if (_checkAGC1 % 3 == 2) |
| { |
| mode = kAgcFixedDigital; |
| str = _T("kAgcFixedDigital"); |
| } |
| TEST(_veApmPtr->SetRxAgcStatus(channel, true, mode) == 0, _T("SetRxAgcStatus(channel=%d, enable=%d, %s)"), channel, enable, str); |
| _checkAGC1++; |
| } |
| else |
| { |
| TEST(_veApmPtr->SetRxAgcStatus(channel, false, kAgcUnchanged) == 0, _T("SetRxAgcStatus(channel=%d, enable=%d)"), channel, enable); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckNs1() |
| { |
| int channel = GetDlgItemInt(IDC_EDIT_1); |
| CButton* buttonNS = (CButton*)GetDlgItem(IDC_CHECK_NS_1); |
| int check = buttonNS->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| if (enable) |
| { |
| CString str; |
| NsModes mode(kNsDefault); |
| if (_checkNS1 % 6 == 0) |
| { |
| mode = kNsDefault; |
| str = _T("kNsDefault"); |
| } |
| else if (_checkNS1 % 6 == 1) |
| { |
| mode = kNsConference; |
| str = _T("kNsConference"); |
| } |
| else if (_checkNS1 % 6 == 2) |
| { |
| mode = kNsLowSuppression; |
| str = _T("kNsLowSuppression"); |
| } |
| else if (_checkNS1 % 6 == 3) |
| { |
| mode = kNsModerateSuppression; |
| str = _T("kNsModerateSuppression"); |
| } |
| else if (_checkNS1 % 6 == 4) |
| { |
| mode = kNsHighSuppression; |
| str = _T("kNsHighSuppression"); |
| } |
| else if (_checkNS1 % 6 == 5) |
| { |
| mode = kNsVeryHighSuppression; |
| str = _T("kNsVeryHighSuppression"); |
| } |
| TEST(_veApmPtr->SetRxNsStatus(channel, true, mode) == 0, _T("SetRxNsStatus(channel=%d, enable=%d, %s)"), channel, enable, str); |
| _checkNS1++; |
| } |
| else |
| { |
| TEST(_veApmPtr->SetRxNsStatus(channel, false, kNsUnchanged) == 0, _T("SetRxNsStatus(channel=%d, enable=%d)"), enable, channel); |
| } |
| } |
| |
| // ---------------------------------------------------------------------------- |
| // Channel-independent Operations |
| // ---------------------------------------------------------------------------- |
| |
| void CWinTestDlg::OnBnClickedCheckPlayFileIn() |
| { |
| // File path is relative to the location of 'voice_engine.gyp'. |
| const char micFile[] = "../../test/data/voice_engine/audio_short16.pcm"; |
| // const char micFile[] = "../../test/data/voice_engine/audio_long16noise.pcm"; |
| |
| int ret(0); |
| int channel(-1); |
| CButton* buttonExtTrans = (CButton*)GetDlgItem(IDC_CHECK_PLAY_FILE_IN); |
| int check = buttonExtTrans->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| if (enable) |
| { |
| bool mix; |
| const bool loop(true); |
| const FileFormats format = kFileFormatPcm16kHzFile; |
| const float scale(1.0); |
| |
| (_checkPlayFileIn %2 == 0) ? mix = true : mix = false; |
| TEST(_veFilePtr->StartPlayingFileAsMicrophone(channel, micFile, loop, mix, format, scale) == 0, |
| _T("StartPlayingFileAsMicrophone(channel=%d, file=%s, loop=%d, mix=%d, format=%d, scale=%2.1f)"), |
| channel, CharToTchar(micFile, -1), loop, mix, format, scale); |
| _checkPlayFileIn++; |
| } |
| else |
| { |
| TEST(_veFilePtr->StopPlayingFileAsMicrophone(channel) == 0, |
| _T("StopPlayingFileAsMicrophone(channel=%d)"), channel); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckRecMic() |
| { |
| const char micFile[] = "/tmp/rec_mic_mono_16kHz.pcm"; |
| |
| CButton* button = (CButton*)GetDlgItem(IDC_CHECK_REC_MIC); |
| int check = button->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| if (enable) |
| { |
| TEST(_veFilePtr->StartRecordingMicrophone(micFile, NULL) == 0, _T("StartRecordingMicrophone(file=%s)"), CharToTchar(micFile, -1)); |
| } |
| else |
| { |
| TEST(_veFilePtr->StopRecordingMicrophone() == 0, _T("StopRecordingMicrophone()")); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckAgc() |
| { |
| CButton* buttonAGC = (CButton*)GetDlgItem(IDC_CHECK_AGC); |
| int check = buttonAGC->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| if (enable) |
| { |
| CString str; |
| AgcModes mode(kAgcDefault); |
| if (_checkAGC % 4 == 0) |
| { |
| mode = kAgcDefault; |
| str = _T("kAgcDefault"); |
| } |
| else if (_checkAGC % 4 == 1) |
| { |
| mode = kAgcAdaptiveAnalog; |
| str = _T("kAgcAdaptiveAnalog"); |
| } |
| else if (_checkAGC % 4 == 2) |
| { |
| mode = kAgcAdaptiveDigital; |
| str = _T("kAgcAdaptiveDigital"); |
| } |
| else if (_checkAGC % 4 == 3) |
| { |
| mode = kAgcFixedDigital; |
| str = _T("kAgcFixedDigital"); |
| } |
| TEST(_veApmPtr->SetAgcStatus(true, mode) == 0, _T("SetAgcStatus(enable=%d, %s)"), enable, str); |
| _checkAGC++; |
| } |
| else |
| { |
| TEST(_veApmPtr->SetAgcStatus(false, kAgcUnchanged) == 0, _T("SetAgcStatus(enable=%d)"), enable); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckNs() |
| { |
| CButton* buttonNS = (CButton*)GetDlgItem(IDC_CHECK_NS); |
| int check = buttonNS->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| if (enable) |
| { |
| CString str; |
| NsModes mode(kNsDefault); |
| if (_checkNS % 6 == 0) |
| { |
| mode = kNsDefault; |
| str = _T("kNsDefault"); |
| } |
| else if (_checkNS % 6 == 1) |
| { |
| mode = kNsConference; |
| str = _T("kNsConference"); |
| } |
| else if (_checkNS % 6 == 2) |
| { |
| mode = kNsLowSuppression; |
| str = _T("kNsLowSuppression"); |
| } |
| else if (_checkNS % 6 == 3) |
| { |
| mode = kNsModerateSuppression; |
| str = _T("kNsModerateSuppression"); |
| } |
| else if (_checkNS % 6 == 4) |
| { |
| mode = kNsHighSuppression; |
| str = _T("kNsHighSuppression"); |
| } |
| else if (_checkNS % 6 == 5) |
| { |
| mode = kNsVeryHighSuppression; |
| str = _T("kNsVeryHighSuppression"); |
| } |
| TEST(_veApmPtr->SetNsStatus(true, mode) == 0, _T("SetNsStatus(enable=%d, %s)"), enable, str); |
| _checkNS++; |
| } |
| else |
| { |
| TEST(_veApmPtr->SetNsStatus(false, kNsUnchanged) == 0, _T("SetNsStatus(enable=%d)"), enable); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckEc() |
| { |
| CButton* buttonEC = (CButton*)GetDlgItem(IDC_CHECK_EC); |
| int check = buttonEC->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| if (enable) |
| { |
| CString str; |
| EcModes mode(kEcDefault); |
| if (_checkEC % 4 == 0) |
| { |
| mode = kEcDefault; |
| str = _T("kEcDefault"); |
| } |
| else if (_checkEC % 4 == 1) |
| { |
| mode = kEcConference; |
| str = _T("kEcConference"); |
| } |
| else if (_checkEC % 4 == 2) |
| { |
| mode = kEcAec; |
| str = _T("kEcAec"); |
| } |
| else if (_checkEC % 4 == 3) |
| { |
| mode = kEcAecm; |
| str = _T("kEcAecm"); |
| } |
| TEST(_veApmPtr->SetEcStatus(true, mode) == 0, _T("SetEcStatus(enable=%d, %s)"), enable, str); |
| _checkEC++; |
| } |
| else |
| { |
| TEST(_veApmPtr->SetEcStatus(false, kEcUnchanged) == 0, _T("SetEcStatus(enable=%d)"), enable); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckMuteIn() |
| { |
| CButton* buttonMute = (CButton*)GetDlgItem(IDC_CHECK_MUTE_IN); |
| int check = buttonMute->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| const int channel(-1); |
| TEST(_veVolumeControlPtr->SetInputMute(channel, enable) == 0, |
| _T("SetInputMute(channel=%d, enable=%d)"), channel, enable); |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckExtMediaIn() |
| { |
| const int channel(-1); |
| CButton* button = (CButton*)GetDlgItem(IDC_CHECK_EXT_MEDIA_IN); |
| int check = button->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| if (enable) |
| { |
| TEST(_veExternalMediaPtr->RegisterExternalMediaProcessing(channel, kRecordingAllChannelsMixed, *_externalMediaPtr) == 0, |
| _T("RegisterExternalMediaProcessing(channel=%d, kRecordingAllChannelsMixed, processObject=0x%x)"), channel, _externalMediaPtr); |
| } |
| else |
| { |
| TEST(_veExternalMediaPtr->DeRegisterExternalMediaProcessing(channel, kRecordingAllChannelsMixed) == 0, |
| _T("DeRegisterExternalMediaProcessing(channel=%d, kRecordingAllChannelsMixed)"), channel); |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckExtMediaOut() |
| { |
| const int channel(-1); |
| CButton* button = (CButton*)GetDlgItem(IDC_CHECK_EXT_MEDIA_OUT); |
| int check = button->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| if (enable) |
| { |
| TEST(_veExternalMediaPtr->RegisterExternalMediaProcessing(channel, kPlaybackAllChannelsMixed, *_externalMediaPtr) == 0, |
| _T("RegisterExternalMediaProcessing(channel=%d, kPlaybackAllChannelsMixed, processObject=0x%x)"), channel, _externalMediaPtr); |
| } |
| else |
| { |
| TEST(_veExternalMediaPtr->DeRegisterExternalMediaProcessing(channel, kPlaybackAllChannelsMixed) == 0, |
| _T("DeRegisterExternalMediaProcessing(channel=%d, kPlaybackAllChannelsMixed)"), channel); |
| } |
| } |
| |
| void CWinTestDlg::OnCbnSelchangeComboRecDevice() |
| { |
| CComboBox* comboCodec(NULL); |
| comboCodec = (CComboBox*)GetDlgItem(IDC_COMBO_REC_DEVICE); |
| int index = comboCodec->GetCurSel(); |
| TEST(_veHardwarePtr->SetRecordingDevice(index) == 0, |
| _T("SetRecordingDevice(index=%d)"), index); |
| } |
| |
| void CWinTestDlg::OnCbnSelchangeComboPlayDevice() |
| { |
| CComboBox* comboCodec(NULL); |
| comboCodec = (CComboBox*)GetDlgItem(IDC_COMBO_PLAY_DEVICE); |
| int index = comboCodec->GetCurSel(); |
| TEST(_veHardwarePtr->SetPlayoutDevice(index) == 0, |
| _T("SetPlayoutDevice(index=%d)"), index); |
| } |
| |
| void CWinTestDlg::OnNMReleasedcaptureSliderInputVolume(NMHDR *pNMHDR, LRESULT *pResult) |
| { |
| CSliderCtrl* slider = (CSliderCtrl*)GetDlgItem(IDC_SLIDER_INPUT_VOLUME); |
| slider->SetRangeMin(0); |
| slider->SetRangeMax(255); |
| int pos = slider->GetPos(); |
| |
| TEST(_veVolumeControlPtr->SetMicVolume(pos) == 0, _T("SetMicVolume(volume=%d)"), pos); |
| |
| *pResult = 0; |
| } |
| |
| void CWinTestDlg::OnNMReleasedcaptureSliderOutputVolume(NMHDR *pNMHDR, LRESULT *pResult) |
| { |
| CSliderCtrl* slider = (CSliderCtrl*)GetDlgItem(IDC_SLIDER_OUTPUT_VOLUME); |
| slider->SetRangeMin(0); |
| slider->SetRangeMax(255); |
| int pos = slider->GetPos(); |
| |
| TEST(_veVolumeControlPtr->SetSpeakerVolume(pos) == 0, _T("SetSpeakerVolume(volume=%d)"), pos); |
| |
| *pResult = 0; |
| } |
| |
| void CWinTestDlg::OnNMReleasedcaptureSliderPanLeft(NMHDR *pNMHDR, LRESULT *pResult) |
| { |
| CSliderCtrl* slider = (CSliderCtrl*)GetDlgItem(IDC_SLIDER_PAN_LEFT); |
| slider->SetRange(0,10); |
| int pos = 10 - slider->GetPos(); // 0 <=> lower end, 10 <=> upper end |
| |
| float left(0.0); |
| float right(0.0); |
| const int channel(-1); |
| |
| // Only left channel will be modified |
| _veVolumeControlPtr->GetOutputVolumePan(channel, left, right); |
| |
| left = (float)((float)pos/10.0f); |
| |
| TEST(_veVolumeControlPtr->SetOutputVolumePan(channel, left, right) == 0, |
| _T("SetOutputVolumePan(channel=%d, left=%2.1f, right=%2.1f)"), channel, left, right); |
| |
| *pResult = 0; |
| } |
| |
| void CWinTestDlg::OnNMReleasedcaptureSliderPanRight(NMHDR *pNMHDR, LRESULT *pResult) |
| { |
| CSliderCtrl* slider = (CSliderCtrl*)GetDlgItem(IDC_SLIDER_PAN_RIGHT); |
| slider->SetRange(0,10); |
| int pos = 10 - slider->GetPos(); // 0 <=> lower end, 10 <=> upper end |
| |
| float left(0.0); |
| float right(0.0); |
| const int channel(-1); |
| |
| // Only right channel will be modified |
| _veVolumeControlPtr->GetOutputVolumePan(channel, left, right); |
| |
| right = (float)((float)pos/10.0f); |
| |
| TEST(_veVolumeControlPtr->SetOutputVolumePan(channel, left, right) == 0, |
| _T("SetOutputVolumePan(channel=%d, left=%2.1f, right=%2.1f)"), channel, left, right); |
| |
| *pResult = 0; |
| } |
| |
| void CWinTestDlg::OnBnClickedButtonVersion() |
| { |
| if (_veBasePtr) |
| { |
| char version[1024]; |
| if (_veBasePtr->GetVersion(version) == 0) |
| { |
| AfxMessageBox(CString(version), MB_OK); |
| } |
| else |
| { |
| AfxMessageBox(_T("FAILED!"), MB_OK); |
| } |
| } |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckRecCall() |
| { |
| // Not supported |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckTypingDetection() |
| { |
| CButton* button = (CButton*)GetDlgItem(IDC_CHECK_TYPING_DETECTION); |
| int check = button->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| TEST(_veApmPtr->SetTypingDetectionStatus(enable) == 0, _T("SetTypingDetectionStatus(enable=%d)"), enable); |
| } |
| |
| void CWinTestDlg::OnBnClickedCheckFEC() |
| { |
| CButton* button = (CButton*)GetDlgItem(IDC_CHECK_FEC); |
| int channel = GetDlgItemInt(IDC_EDIT_1); |
| int check = button->GetCheck(); |
| const bool enable = (check == BST_CHECKED); |
| TEST(_veRtpRtcpPtr->SetFECStatus(channel, enable) == 0, _T("SetFECStatus(enable=%d)"), enable); |
| } |
| |
| // ---------------------------------------------------------------------------- |
| // Message Handlers |
| // ---------------------------------------------------------------------------- |
| |
| void CWinTestDlg::OnTimer(UINT_PTR nIDEvent) |
| { |
| CString str; |
| |
| unsigned int svol(0); |
| unsigned int mvol(0); |
| |
| _timerTicks++; |
| |
| // Get speaker and microphone volumes |
| _veVolumeControlPtr->GetSpeakerVolume(svol); |
| _veVolumeControlPtr->GetMicVolume(mvol); |
| |
| // Update speaker volume slider |
| CSliderCtrl* sliderSpkr = (CSliderCtrl*)GetDlgItem(IDC_SLIDER_OUTPUT_VOLUME); |
| sliderSpkr->SetRangeMin(0); |
| sliderSpkr->SetRangeMax(255); |
| sliderSpkr->SetPos(svol); |
| |
| // Update microphone volume slider |
| CSliderCtrl* sliderMic = (CSliderCtrl*)GetDlgItem(IDC_SLIDER_INPUT_VOLUME); |
| sliderMic->SetRangeMin(0); |
| sliderMic->SetRangeMax(255); |
| sliderMic->SetPos(mvol); |
| |
| unsigned int micLevel; |
| unsigned int combinedOutputLevel; |
| |
| // Get audio levels |
| _veVolumeControlPtr->GetSpeechInputLevel(micLevel); |
| _veVolumeControlPtr->GetSpeechOutputLevel(-1, combinedOutputLevel); |
| |
| // Update audio level controls |
| CProgressCtrl* progressMic = (CProgressCtrl*)GetDlgItem(IDC_PROGRESS_AUDIO_LEVEL_IN); |
| progressMic->SetRange(0,9); |
| progressMic->SetStep(1); |
| progressMic->SetPos(micLevel); |
| CProgressCtrl* progressOut = (CProgressCtrl*)GetDlgItem(IDC_PROGRESS_AUDIO_LEVEL_OUT); |
| progressOut->SetRange(0,9); |
| progressOut->SetStep(1); |
| progressOut->SetPos(combinedOutputLevel); |
| |
| // Update playout delay (buffer size) |
| if (_veVideoSyncPtr) |
| { |
| int bufferMs(0); |
| _veVideoSyncPtr->GetPlayoutBufferSize(bufferMs); |
| SetDlgItemInt(IDC_EDIT_PLAYOUT_BUFFER_SIZE, bufferMs); |
| } |
| |
| if (_delayEstimate1 && _veVideoSyncPtr) |
| { |
| const int channel = GetDlgItemInt(IDC_EDIT_1); |
| int delayMs(0); |
| _veVideoSyncPtr->GetDelayEstimate(channel, delayMs); |
| SetDlgItemInt(IDC_EDIT_DELAY_ESTIMATE_1, delayMs); |
| } |
| |
| if (_rxVad && _veApmPtr && _rxVadObserverPtr) |
| { |
| SetDlgItemInt(IDC_EDIT_RXVAD, _rxVadObserverPtr->_vadDecision); |
| } |
| |
| if (_veHardwarePtr) |
| { |
| int load1, load2; |
| _veHardwarePtr->GetSystemCPULoad(load1); |
| _veHardwarePtr->GetCPULoad(load2); |
| str.Format(_T("CPU load (system/VoE): %d/%d [%%]"), load1, load2); |
| SetDlgItemText(IDC_EDIT_CPU_LOAD, (LPCTSTR)str); |
| } |
| |
| BOOL ret; |
| int channel = GetDlgItemInt(IDC_EDIT_1, &ret); |
| |
| if (_veCodecPtr) |
| { |
| if (ret == TRUE) |
| { |
| CodecInst codec; |
| if (_veCodecPtr->GetRecCodec(channel, codec) == 0) |
| { |
| str.Format(_T("RX codec: %s, freq=%d, pt=%d, rate=%d, size=%d"), CharToTchar(codec.plname, 32), codec.plfreq, codec.pltype, codec.rate, codec.pacsize); |
| SetDlgItemText(IDC_EDIT_RX_CODEC_1, (LPCTSTR)str); |
| } |
| } |
| } |
| |
| if (_veRtpRtcpPtr) |
| { |
| if (ret == TRUE) |
| { |
| CallStatistics stats; |
| if (_veRtpRtcpPtr->GetRTCPStatistics(channel, stats) == 0) |
| { |
| str.Format(_T("RTCP | RTP: cum=%u, ext=%d, frac=%u, jitter=%u | TX=%d, RX=%d, RTT=%d"), |
| stats.cumulativeLost, stats.extendedMax, stats.fractionLost, stats.jitterSamples, stats.packetsSent, stats.packetsReceived, stats.rttMs); |
| SetDlgItemText(IDC_EDIT_RTCP_STAT_1, (LPCTSTR)str); |
| } |
| } |
| } |
| |
| SetTimer(0, 1000, NULL); |
| CDialog::OnTimer(nIDEvent); |
| } |
| |
| void CWinTestDlg::OnBnClickedButtonClearErrorCallback() |
| { |
| _nErrorCallbacks = 0; |
| SetDlgItemText(IDC_EDIT_ERROR_CALLBACK, _T("")); |
| } |
| |
| // ---------------------------------------------------------------------------- |
| // TEST |
| // ---------------------------------------------------------------------------- |
| |
| void CWinTestDlg::OnBnClickedButtonTest1() |
| { |
| // add tests here... |
| } |
| |
