| /* |
| * Copyright (c) 2012 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. |
| */ |
| |
| /* |
| * vie_autotest_custom_call.cc |
| * |
| */ |
| |
| #include <iostream> |
| |
| #include "vie_autotest.h" |
| #include "vie_autotest_defines.h" |
| |
| #define VCM_RED_PAYLOAD_TYPE 96 |
| #define VCM_ULPFEC_PAYLOAD_TYPE 97 |
| #define DEFAULT_SEND_IP "127.0.0.1" |
| #define DEFAULT_VIDEO_PORT 11111 |
| #define DEFAULT_VIDEO_CODEC "vp8" |
| #define DEFAULT_VIDEO_CODEC_WIDTH 640 |
| #define DEFAULT_VIDEO_CODEC_HEIGHT 480 |
| #define DEFAULT_VIDEO_CODEC_BITRATE 300 |
| #define DEFAULT_VIDEO_CODEC_MIN_BITRATE 100 |
| #define DEFAULT_VIDEO_CODEC_MAX_BITRATE 1000 |
| #define DEFAULT_AUDIO_PORT 11113 |
| #define DEFAULT_AUDIO_CODEC "ISAC" |
| #define DEFAULT_INCOMING_FILE_NAME "IncomingFile.avi" |
| #define DEFAULT_OUTGOING_FILE_NAME "OutgoingFile.avi" |
| #define DEFAULT_VIDEO_CODEC_MAX_FRAMERATE 30 |
| #define DEFAULT_VIDEO_PROTECTION_METHOD 0 |
| #define DEFAULT_TEMPORAL_LAYER 0 |
| |
| enum StatisticsType { |
| kSendStatistic, |
| kReceivedStatistic |
| }; |
| |
| class ViEAutotestFileObserver: public webrtc::ViEFileObserver { |
| public: |
| ViEAutotestFileObserver() {}; |
| ~ViEAutotestFileObserver() {}; |
| |
| void PlayFileEnded(const WebRtc_Word32 fileId) { |
| ViETest::Log("PlayFile ended"); |
| } |
| }; |
| |
| class ViEAutotestEncoderObserver: public webrtc::ViEEncoderObserver { |
| public: |
| ViEAutotestEncoderObserver() {}; |
| ~ViEAutotestEncoderObserver() {}; |
| |
| void OutgoingRate(const int videoChannel, |
| const unsigned int framerate, |
| const unsigned int bitrate) { |
| std::cout << "Send FR: " << framerate |
| << " BR: " << bitrate << std::endl; |
| } |
| }; |
| |
| class ViEAutotestDecoderObserver: public webrtc::ViEDecoderObserver { |
| public: |
| ViEAutotestDecoderObserver() {}; |
| ~ViEAutotestDecoderObserver() {}; |
| |
| void IncomingRate(const int videoChannel, |
| const unsigned int framerate, |
| const unsigned int bitrate) { |
| std::cout << "Received FR: " << framerate |
| << " BR: " << bitrate << std::endl; |
| } |
| void IncomingCodecChanged(const int videoChannel, |
| const webrtc::VideoCodec& codec) {} |
| void RequestNewKeyFrame(const int videoChannel) { |
| std::cout << "Decoder requesting a new key frame." << std::endl; |
| } |
| }; |
| |
| // The following are general helper functions. |
| bool GetVideoDevice(webrtc::ViEBase* ptrViEBase, |
| webrtc::ViECapture* ptrViECapture, |
| char* captureDeviceName, char* captureDeviceUniqueId); |
| bool GetIPAddress(char* IP); |
| #ifndef WEBRTC_ANDROID |
| bool ValidateIP(std::string iStr); |
| #endif |
| // The following are Print to stdout functions. |
| void PrintCallInformation(char* IP, char* videoCaptureDeviceName, |
| char* videoCaptureUniqueId, |
| webrtc::VideoCodec videoCodec, int videoTxPort, |
| int videoRxPort, char* audioCaptureDeviceName, |
| char* audioPlaybackDeviceName, |
| webrtc::CodecInst audioCodec, int audioTxPort, |
| int audioRxPort, int protectionMethod); |
| void PrintRTCCPStatistics(webrtc::ViERTP_RTCP* ptrViERtpRtcp, |
| int videoChannel, StatisticsType statType); |
| void PrintRTPStatistics(webrtc::ViERTP_RTCP* ptrViERtpRtcp, |
| int videoChannel); |
| void PrintBandwidthUsage(webrtc::ViERTP_RTCP* ptrViERtpRtcp, |
| int videoChannel); |
| void PrintCodecStatistics(webrtc::ViECodec* ptrViECodec, int videoChannel, |
| StatisticsType statType); |
| void PrintGetDiscardedPackets(webrtc::ViECodec* ptrViECodec, int videoChannel); |
| void PrintVideoStreamInformation(webrtc::ViECodec* ptrViECodec, |
| int videoChannel); |
| void PrintVideoCodec(webrtc::VideoCodec videoCodec); |
| |
| // The following are video functions. |
| // TODO(amyfong): change to pointers as input arguments |
| // instead of references |
| bool SetVideoPorts(int* txPort, int* rxPort); |
| bool SetVideoCodecType(webrtc::ViECodec* ptrViECodec, |
| webrtc::VideoCodec& videoCodec); |
| bool SetVideoCodecResolution(webrtc::ViECodec* ptrViECodec, |
| webrtc::VideoCodec& videoCodec); |
| bool SetVideoCodecSize(webrtc::ViECodec* ptrViECodec, |
| webrtc::VideoCodec& videoCodec); |
| bool SetVideoCodecBitrate(webrtc::ViECodec* ptrViECodec, |
| webrtc::VideoCodec& videoCodec); |
| bool SetVideoCodecMinBitrate(webrtc::ViECodec* ptrViECodec, |
| webrtc::VideoCodec& videoCodec); |
| bool SetVideoCodecMaxBitrate(webrtc::ViECodec* ptrViECodec, |
| webrtc::VideoCodec& videoCodec); |
| bool SetVideoCodecMaxFramerate(webrtc::ViECodec* ptrViECodec, |
| webrtc::VideoCodec& videoCodec); |
| bool SetVideoCodecTemporalLayer(webrtc::VideoCodec& videoCodec); |
| int GetVideoProtection(); |
| bool SetVideoProtection(webrtc::ViECodec* ptrViECodec, |
| webrtc::ViERTP_RTCP* ptrViERtpRtcp, |
| int videoChannel, int protectionMethod); |
| bool GetBitrateSignaling(); |
| |
| // The following are audio helper functions. |
| bool GetAudioDevices(webrtc::VoEBase* ptrVEBase, |
| webrtc::VoEHardware* ptrVEHardware, |
| char* recordingDeviceName, int& recordingDeviceIndex, |
| char* playbackDeviceName, int& playbackDeviceIndex); |
| bool GetAudioDevices(webrtc::VoEBase* ptrVEBase, |
| webrtc::VoEHardware* ptrVEHardware, |
| int& recordingDeviceIndex, int& playbackDeviceIndex); |
| bool GetAudioPorts(int* txPort, int* rxPort); |
| bool GetAudioCodec(webrtc::VoECodec* ptrVeCodec, |
| webrtc::CodecInst& audioCodec); |
| |
| int ViEAutoTest::ViECustomCall() |
| { |
| ViETest::Log(" "); |
| ViETest::Log("========================================"); |
| ViETest::Log(" Enter values to use custom settings\n"); |
| |
| int error = 0; |
| int numberOfErrors = 0; |
| std::string str; |
| |
| // Create the VoE and get the VoE interfaces. |
| webrtc::VoiceEngine* ptrVE = webrtc::VoiceEngine::Create(); |
| numberOfErrors += ViETest::TestError(ptrVE != NULL, "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| webrtc::VoEBase* ptrVEBase = webrtc::VoEBase::GetInterface(ptrVE); |
| numberOfErrors += ViETest::TestError(ptrVEBase != NULL, |
| "ERROR: %s at line %d", __FUNCTION__, |
| __LINE__); |
| |
| error = ptrVEBase->Init(); |
| numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| webrtc::VoECodec* ptrVECodec = webrtc::VoECodec::GetInterface(ptrVE); |
| numberOfErrors += ViETest::TestError(ptrVECodec != NULL, |
| "ERROR: %s at line %d", __FUNCTION__, |
| __LINE__); |
| |
| webrtc::VoEHardware* ptrVEHardware = |
| webrtc::VoEHardware::GetInterface(ptrVE); |
| numberOfErrors += ViETest::TestError(ptrVEHardware != NULL, |
| "ERROR: %s at line %d", __FUNCTION__, |
| __LINE__); |
| |
| webrtc::VoEAudioProcessing* ptrVEAPM = |
| webrtc::VoEAudioProcessing::GetInterface(ptrVE); |
| numberOfErrors += ViETest::TestError(ptrVEAPM != NULL, |
| "ERROR: %s at line %d", __FUNCTION__, |
| __LINE__); |
| |
| // Create the ViE and get the ViE Interfaces. |
| webrtc::VideoEngine* ptrViE = webrtc::VideoEngine::Create(); |
| numberOfErrors += ViETest::TestError(ptrViE != NULL, |
| "ERROR: %s at line %d", __FUNCTION__, |
| __LINE__); |
| |
| webrtc::ViEBase* ptrViEBase = webrtc::ViEBase::GetInterface(ptrViE); |
| numberOfErrors += ViETest::TestError(ptrViEBase != NULL, |
| "ERROR: %s at line %d", __FUNCTION__, |
| __LINE__); |
| |
| error = ptrViEBase->Init(); |
| numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| webrtc::ViECapture* ptrViECapture = |
| webrtc::ViECapture::GetInterface(ptrViE); |
| numberOfErrors += ViETest::TestError(ptrViECapture != NULL, |
| "ERROR: %s at line %d", __FUNCTION__, |
| __LINE__); |
| |
| webrtc::ViERender* ptrViERender = webrtc::ViERender::GetInterface(ptrViE); |
| numberOfErrors += ViETest::TestError(ptrViERender != NULL, |
| "ERROR: %s at line %d", __FUNCTION__, |
| __LINE__); |
| |
| webrtc::ViECodec* ptrViECodec = webrtc::ViECodec::GetInterface(ptrViE); |
| numberOfErrors += ViETest::TestError(ptrViECodec != NULL, |
| "ERROR: %s at line %d", __FUNCTION__, |
| __LINE__); |
| |
| webrtc::ViENetwork* ptrViENetwork = |
| webrtc::ViENetwork::GetInterface(ptrViE); |
| numberOfErrors += ViETest::TestError(ptrViENetwork != NULL, |
| "ERROR: %s at line %d", __FUNCTION__, |
| __LINE__); |
| |
| webrtc::ViEFile* ptrViEFile = webrtc::ViEFile::GetInterface(ptrViE); |
| numberOfErrors += ViETest::TestError(ptrViEFile != NULL, |
| "ERROR: %s at line %d", __FUNCTION__, |
| __LINE__); |
| |
| bool startCall = false; |
| const unsigned int kMaxIPLength = 16; |
| char ipAddress[kMaxIPLength] = ""; |
| const unsigned int KMaxUniqueIdLength = 256; |
| char uniqueId[KMaxUniqueIdLength] = ""; |
| char deviceName[KMaxUniqueIdLength] = ""; |
| int videoTxPort = 0; |
| int videoRxPort = 0; |
| int videoChannel = -1; |
| webrtc::VideoCodec videoSendCodec; |
| char audioCaptureDeviceName[KMaxUniqueIdLength] = ""; |
| char audioPlaybackDeviceName[KMaxUniqueIdLength] = ""; |
| int audioCaptureDeviceIndex = -1; |
| int audioPlaybackDeviceIndex = -1; |
| int audioTxPort = 0; |
| int audioRxPort = 0; |
| webrtc::CodecInst audioCodec; |
| int audioChannel = -1; |
| bool isImageScaleEnabled = false; |
| int protectionMethod = DEFAULT_VIDEO_PROTECTION_METHOD; |
| bool remb = true; |
| |
| while (!startCall) { |
| // Get the IP address to use from call. |
| memset(ipAddress, 0, kMaxIPLength); |
| GetIPAddress(ipAddress); |
| |
| // Get the video device to use for call. |
| memset(deviceName, 0, KMaxUniqueIdLength); |
| memset(uniqueId, 0, KMaxUniqueIdLength); |
| GetVideoDevice(ptrViEBase, ptrViECapture, deviceName, uniqueId); |
| |
| // Get and set the video ports for the call. |
| videoTxPort = 0; |
| videoRxPort = 0; |
| SetVideoPorts(&videoTxPort, &videoRxPort); |
| |
| // Get and set the video codec parameters for the call. |
| memset((void*)&videoSendCodec, 0, sizeof(webrtc::VideoCodec)); |
| SetVideoCodecType(ptrViECodec, videoSendCodec); |
| SetVideoCodecSize(ptrViECodec, videoSendCodec); |
| SetVideoCodecBitrate(ptrViECodec, videoSendCodec); |
| SetVideoCodecMinBitrate(ptrViECodec, videoSendCodec); |
| SetVideoCodecMaxBitrate(ptrViECodec, videoSendCodec); |
| SetVideoCodecMaxFramerate(ptrViECodec, videoSendCodec); |
| SetVideoCodecTemporalLayer(videoSendCodec); |
| remb = GetBitrateSignaling(); |
| |
| // Get the video protection method for the call. |
| protectionMethod = GetVideoProtection(); |
| |
| // Get the audio device for the call. |
| memset(audioCaptureDeviceName, 0, KMaxUniqueIdLength); |
| memset(audioPlaybackDeviceName, 0, KMaxUniqueIdLength); |
| GetAudioDevices(ptrVEBase, ptrVEHardware, audioCaptureDeviceName, |
| audioCaptureDeviceIndex, audioPlaybackDeviceName, |
| audioPlaybackDeviceIndex); |
| |
| // Get the audio port for the call. |
| audioTxPort = 0; |
| audioRxPort = 0; |
| GetAudioPorts(&audioTxPort, &audioRxPort); |
| |
| // Get the audio codec for the call. |
| memset((void*)&audioCodec, 0, sizeof(audioCodec)); |
| GetAudioCodec(ptrVECodec, audioCodec); |
| |
| // Now ready to start the call. Check user wants to continue. |
| PrintCallInformation(ipAddress, deviceName, uniqueId, videoSendCodec, |
| videoTxPort, videoRxPort, audioCaptureDeviceName, |
| audioPlaybackDeviceName, audioCodec, audioTxPort, |
| audioRxPort, protectionMethod); |
| |
| std::cout << std::endl; |
| std::cout << "1. Start the call" << std::endl; |
| std::cout << "2. Reconfigure call settings" << std::endl; |
| std::cout << "What do you want to do? Press enter for default " |
| << "(Start the call): "; |
| |
| std::getline(std::cin, str); |
| int selection = 0; |
| selection = atoi(str.c_str()); |
| |
| switch (selection) { |
| case 0: |
| startCall = true; |
| break; |
| case 1: |
| startCall = true; |
| break; |
| case 2: |
| startCall = false; |
| break; |
| default: |
| // Invalid selection gets error mesage. |
| std::cout << "ERROR: Code=" << error |
| << " Invalid selection" << std::endl; |
| continue; |
| } |
| } |
| //*************************************************************** |
| // Begin create/initialize WebRTC Video Engine for testing. |
| //*************************************************************** |
| if (startCall == true) { |
| // Configure audio channel first. |
| audioChannel = ptrVEBase->CreateChannel(); |
| error = ptrVEBase->SetSendDestination(audioChannel, audioTxPort, |
| ipAddress); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| error = ptrVEBase->SetLocalReceiver(audioChannel, audioRxPort); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| error = ptrVEHardware->SetRecordingDevice(audioCaptureDeviceIndex); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| error = ptrVEHardware->SetPlayoutDevice(audioPlaybackDeviceIndex); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| error = ptrVECodec->SetSendCodec(audioChannel, audioCodec); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| error = ptrVEAPM->SetAgcStatus(true, webrtc::kAgcDefault); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| error = ptrVEAPM->SetNsStatus(true, webrtc::kNsHighSuppression); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| // Now configure the video channel. |
| error = ptrViE->SetTraceFilter(webrtc::kTraceAll); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| std::string trace_file = |
| ViETest::GetResultOutputPath() + "ViECustomCall_trace.txt"; |
| error = ptrViE->SetTraceFile(trace_file.c_str()); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| error = ptrViEBase->SetVoiceEngine(ptrVE); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| error = ptrViEBase->CreateChannel(videoChannel); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| error = ptrViEBase->ConnectAudioChannel(videoChannel, audioChannel); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| int captureId = 0; |
| error = ptrViECapture->AllocateCaptureDevice(uniqueId, |
| KMaxUniqueIdLength, |
| captureId); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| error = ptrViECapture->ConnectCaptureDevice(captureId, videoChannel); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| error = ptrViECapture->StartCapture(captureId); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| webrtc::ViERTP_RTCP* ptrViERtpRtcp = |
| webrtc::ViERTP_RTCP::GetInterface(ptrViE); |
| numberOfErrors += ViETest::TestError(ptrViE != NULL, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| error = ptrViERtpRtcp->SetRTCPStatus(videoChannel, |
| webrtc::kRtcpCompound_RFC4585); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| error = ptrViERtpRtcp->SetKeyFrameRequestMethod(videoChannel, |
| webrtc::kViEKeyFrameRequestPliRtcp); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| if (remb) { |
| error = ptrViERtpRtcp->SetRembStatus(videoChannel, true, true); |
| numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| } else { |
| error = ptrViERtpRtcp->SetTMMBRStatus(videoChannel, true); |
| numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| } |
| |
| error = ptrViERender->AddRenderer(captureId, _window1, 0, 0.0, 0.0, |
| 1.0, 1.0); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| error = ptrViERender->AddRenderer(videoChannel, _window2, 1, 0.0, 0.0, |
| 1.0, 1.0); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| error = ptrViENetwork->SetSendDestination(videoChannel, ipAddress, |
| videoTxPort); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| error = ptrViENetwork->SetLocalReceiver(videoChannel, videoRxPort); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| error = ptrViECodec->SetSendCodec(videoChannel, videoSendCodec); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| error = ptrViECodec->SetReceiveCodec(videoChannel, videoSendCodec); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| // Set the Video Protection before start send and receive. |
| SetVideoProtection(ptrViECodec, ptrViERtpRtcp, |
| videoChannel, protectionMethod); |
| |
| // Start Voice Playout and Receive. |
| error = ptrVEBase->StartReceive(audioChannel); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| error = ptrVEBase->StartPlayout(audioChannel); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| error = ptrVEBase->StartSend(audioChannel); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| // Now start the Video Send & Receive. |
| error = ptrViEBase->StartSend(videoChannel); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| error = ptrViEBase->StartReceive(videoChannel); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| error = ptrViERender->StartRender(captureId); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| error = ptrViERender->StartRender(videoChannel); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| ViEAutotestFileObserver fileObserver; |
| int fileId; |
| |
| ViEAutotestEncoderObserver* codecEncoderObserver = NULL; |
| ViEAutotestDecoderObserver* codecDecoderObserver = NULL; |
| |
| //*************************************************************** |
| // Engine ready. Wait for input |
| //*************************************************************** |
| |
| // Call started. |
| std::cout << std::endl; |
| std::cout << "Custom call started" << std::endl; |
| std::cout << std::endl << std::endl; |
| |
| // Modify call or stop call. |
| |
| std::cout << "Custom call in progress, would you like do?" << std::endl; |
| std::cout << " 0. Stop the call" << std::endl; |
| std::cout << " 1. Modify the call" << std::endl; |
| std::cout << "What do you want to do? " |
| << "Press enter for default (Stop the call): "; |
| |
| std::getline(std::cin, str); |
| int selection = 0; |
| selection = atoi(str.c_str()); |
| |
| // Keep on modifying the call until user selects finish modify call. |
| bool modify_call = false; |
| |
| while (selection == 1) { |
| std::cout << "Modify Custom Call" << std::endl; |
| std::cout << " 0. Finished modifying custom call" << std::endl; |
| std::cout << " 1. Change Video Send Codec" << std::endl; |
| std::cout << " 2. Change Video Send Size by Common Resolutions" |
| << std::endl; |
| std::cout << " 3. Change Video Send Size by Width & Height" << std::endl; |
| std::cout << " 4. Change Video Capture Device" << std::endl; |
| std::cout << " 5. Record Incoming Call" << std::endl; |
| std::cout << " 6. Record Outgoing Call" << std::endl; |
| std::cout << " 7. Play File on Video Channel" |
| << "(Assumes you recorded incoming & outgoing call)" |
| << std::endl; |
| std::cout << " 8. Change Video Protection Method" << std::endl; |
| std::cout << " 9. Toggle Encoder Observer" << std::endl; |
| std::cout << " 10. Toggle Decoder Observer" << std::endl; |
| std::cout << " 11. Print Call Information" << std::endl; |
| std::cout << " 12. Print Call Statistics" << std::endl; |
| std::cout << " 13. Toggle Image Scaling " |
| << "(Warning high CPU usage when enabled)" |
| << std::endl; |
| std::cout << "What do you want to do? "; |
| std::cout << "Press enter for default " |
| << "(Finished modifying custom call): "; |
| |
| std::getline(std::cin, str); |
| int modify_selection = 0; |
| int file_selection = 0; |
| |
| modify_selection = atoi(str.c_str()); |
| |
| switch (modify_selection) { |
| case 0: |
| std::cout << "Finished modifying custom call." << std::endl; |
| modify_call = false; |
| break; |
| case 1: |
| // Change video Codec |
| SetVideoCodecType(ptrViECodec, videoSendCodec); |
| SetVideoCodecSize(ptrViECodec, videoSendCodec); |
| SetVideoCodecBitrate(ptrViECodec, videoSendCodec); |
| SetVideoCodecMinBitrate(ptrViECodec, videoSendCodec); |
| SetVideoCodecMaxBitrate(ptrViECodec, videoSendCodec); |
| SetVideoCodecMaxFramerate(ptrViECodec, videoSendCodec); |
| SetVideoCodecTemporalLayer(videoSendCodec); |
| PrintCallInformation(ipAddress, deviceName, |
| uniqueId, videoSendCodec, |
| videoTxPort, videoRxPort, |
| audioCaptureDeviceName, |
| audioPlaybackDeviceName, audioCodec, |
| audioTxPort, audioRxPort, protectionMethod); |
| error = ptrViECodec->SetSendCodec(videoChannel, videoSendCodec); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| error = ptrViECodec->SetReceiveCodec(videoChannel, videoSendCodec); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| modify_call = true; |
| break; |
| case 2: |
| // Change Video codec size by common resolution |
| SetVideoCodecResolution(ptrViECodec, videoSendCodec); |
| PrintCallInformation(ipAddress, deviceName, |
| uniqueId, videoSendCodec, |
| videoTxPort, videoRxPort, |
| audioCaptureDeviceName, |
| audioPlaybackDeviceName, audioCodec, |
| audioTxPort, audioRxPort, protectionMethod); |
| error = ptrViECodec->SetSendCodec(videoChannel, videoSendCodec); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| error = ptrViECodec->SetReceiveCodec(videoChannel, videoSendCodec); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| modify_call = true; |
| break; |
| case 3: |
| // Change Video codec by size height and width |
| SetVideoCodecSize(ptrViECodec, videoSendCodec); |
| PrintCallInformation(ipAddress, deviceName, |
| uniqueId, videoSendCodec, |
| videoTxPort, videoRxPort, |
| audioCaptureDeviceName, |
| audioPlaybackDeviceName, audioCodec, |
| audioTxPort, audioRxPort, protectionMethod); |
| error = ptrViECodec->SetSendCodec(videoChannel, videoSendCodec); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| error = ptrViECodec->SetReceiveCodec(videoChannel, videoSendCodec); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| modify_call = true; |
| break; |
| case 4: |
| error = ptrViERender->StopRender(captureId); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| error = ptrViERender->RemoveRenderer(captureId); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| error = ptrViECapture->StopCapture(captureId); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| error = ptrViECapture->DisconnectCaptureDevice(videoChannel); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| error = ptrViECapture->ReleaseCaptureDevice(captureId); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| memset(deviceName, 0, KMaxUniqueIdLength); |
| memset(uniqueId, 0, KMaxUniqueIdLength); |
| GetVideoDevice(ptrViEBase, ptrViECapture, deviceName, uniqueId); |
| captureId = 0; |
| error = ptrViECapture->AllocateCaptureDevice(uniqueId, |
| KMaxUniqueIdLength, |
| captureId); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| error = ptrViECapture->ConnectCaptureDevice(captureId, |
| videoChannel); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| error = ptrViECapture->StartCapture(captureId); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| error = ptrViERender->AddRenderer( |
| captureId, _window1, 0, 0.0, 0.0, 1.0, 1.0); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| error = ptrViERender->StartRender(captureId); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| modify_call = true; |
| break; |
| case 5: |
| // Record the incoming call |
| std::cout << "Start Recording Incoming Video " |
| << DEFAULT_INCOMING_FILE_NAME << std::endl; |
| error = ptrViEFile->StartRecordIncomingVideo( |
| videoChannel, DEFAULT_INCOMING_FILE_NAME, |
| webrtc::NO_AUDIO, audioCodec, videoSendCodec); |
| std::cout << "Press enter to stop..."; |
| std::getline(std::cin, str); |
| error = ptrViEFile->StopRecordIncomingVideo(videoChannel); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR:%d %s at line %d", |
| ptrViEBase->LastError(), |
| __FUNCTION__, __LINE__); |
| modify_call = true; |
| break; |
| case 6: |
| // Record the outgoing call |
| std::cout << "Start Recording Outgoing Video " |
| << DEFAULT_OUTGOING_FILE_NAME << std::endl; |
| error = ptrViEFile->StartRecordOutgoingVideo( |
| videoChannel, DEFAULT_OUTGOING_FILE_NAME, |
| webrtc::NO_AUDIO, audioCodec, videoSendCodec); |
| std::cout << "Press enter to stop..."; |
| std::getline(std::cin, str); |
| error = ptrViEFile->StopRecordOutgoingVideo(videoChannel); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR:%d %s at line %d", |
| ptrViEBase->LastError(), |
| __FUNCTION__, __LINE__); |
| modify_call = true; |
| break; |
| case 7: |
| // Send the file on the videoChannel |
| file_selection = 0; |
| std::cout << "Available files to play" << std::endl; |
| std::cout << " 0. " << DEFAULT_INCOMING_FILE_NAME << std::endl; |
| std::cout << " 1. " << DEFAULT_OUTGOING_FILE_NAME << std::endl; |
| std::cout << "Press enter for default (" |
| << DEFAULT_INCOMING_FILE_NAME << "): "; |
| std::getline(std::cin, str); |
| file_selection = atoi(str.c_str()); |
| // Disconnect the camera first |
| error = ptrViECapture->DisconnectCaptureDevice(videoChannel); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR:%d %s at line %d", |
| ptrViEBase->LastError(), |
| __FUNCTION__, __LINE__); |
| if (file_selection == 1) |
| error = ptrViEFile->StartPlayFile(DEFAULT_OUTGOING_FILE_NAME, |
| fileId, true); |
| else |
| error = ptrViEFile->StartPlayFile(DEFAULT_INCOMING_FILE_NAME, |
| fileId, true); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR:%d %s at line %d", |
| ptrViEBase->LastError(), |
| __FUNCTION__, __LINE__); |
| ViETest::Log("Registering file observer"); |
| error = ptrViEFile->RegisterObserver(fileId, fileObserver); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR:%d %s at line %d", |
| ptrViEBase->LastError(), |
| __FUNCTION__, __LINE__); |
| std::cout << std::endl; |
| std::cout << "Start sending the file that is played in a loop " |
| << std::endl; |
| error = ptrViEFile->SendFileOnChannel(fileId, videoChannel); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR:%d %s at line %d", |
| ptrViEBase->LastError(), |
| __FUNCTION__, __LINE__); |
| std::cout << "Press enter to stop..."; |
| std::getline(std::cin, str); |
| ViETest::Log("Stopped sending video on channel"); |
| error = ptrViEFile->StopSendFileOnChannel(videoChannel); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR:%d %s at line %d", |
| ptrViEBase->LastError(), |
| __FUNCTION__, __LINE__); |
| ViETest::Log("Stop playing the file."); |
| error = ptrViEFile->StopPlayFile(fileId); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR:%d %s at line %d", |
| ptrViEBase->LastError(), |
| __FUNCTION__, __LINE__); |
| error = ptrViECapture->ConnectCaptureDevice(captureId, |
| videoChannel); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR:%d %s at line %d", |
| ptrViEBase->LastError(), |
| __FUNCTION__, __LINE__); |
| error = ptrViEFile->DeregisterObserver(fileId, fileObserver); |
| numberOfErrors += ViETest::TestError(error == -1, |
| "ERROR:%d %s at line %d", |
| ptrViEBase->LastError(), |
| __FUNCTION__, __LINE__); |
| modify_call = true; |
| break; |
| case 8: |
| // Change the Video Protection |
| protectionMethod = GetVideoProtection(); |
| SetVideoProtection(ptrViECodec, ptrViERtpRtcp, |
| videoChannel, protectionMethod); |
| modify_call = true; |
| break; |
| case 9: |
| // Toggle Encoder Observer |
| if (!codecEncoderObserver) { |
| std::cout << "Registering Encoder Observer" << std::endl; |
| codecEncoderObserver = new ViEAutotestEncoderObserver(); |
| error = ptrViECodec->RegisterEncoderObserver(videoChannel, |
| *codecEncoderObserver); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| } else { |
| std::cout << "Deregistering Encoder Observer" << std::endl; |
| error = ptrViECodec->DeregisterEncoderObserver(videoChannel); |
| delete codecEncoderObserver; |
| codecEncoderObserver = NULL; |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| } |
| modify_call = true; |
| break; |
| case 10: |
| // Toggle Decoder Observer |
| if (!codecDecoderObserver) { |
| std::cout << "Registering Decoder Observer" << std::endl; |
| codecDecoderObserver = new ViEAutotestDecoderObserver(); |
| error = ptrViECodec->RegisterDecoderObserver(videoChannel, |
| *codecDecoderObserver); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| } else { |
| std::cout << "Deregistering Decoder Observer" << std::endl; |
| error = ptrViECodec->DeregisterDecoderObserver(videoChannel); |
| delete codecDecoderObserver; |
| codecDecoderObserver = NULL; |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| } |
| modify_call = true; |
| break; |
| case 11: |
| // Print Call information |
| PrintCallInformation(ipAddress, deviceName, |
| uniqueId, videoSendCodec, |
| videoTxPort, videoRxPort, |
| audioCaptureDeviceName, |
| audioPlaybackDeviceName, |
| audioCodec, audioTxPort, |
| audioRxPort, protectionMethod); |
| PrintVideoStreamInformation(ptrViECodec, |
| videoChannel); |
| modify_call = true; |
| break; |
| case 12: |
| // Print Call statistics |
| PrintRTCCPStatistics(ptrViERtpRtcp, videoChannel, |
| kSendStatistic); |
| PrintRTCCPStatistics(ptrViERtpRtcp, videoChannel, |
| kReceivedStatistic); |
| PrintRTPStatistics(ptrViERtpRtcp, videoChannel); |
| PrintBandwidthUsage(ptrViERtpRtcp, videoChannel); |
| PrintCodecStatistics(ptrViECodec, videoChannel, |
| kSendStatistic); |
| PrintCodecStatistics(ptrViECodec, videoChannel, |
| kReceivedStatistic); |
| PrintGetDiscardedPackets(ptrViECodec, videoChannel); |
| modify_call = true; |
| break; |
| case 13: |
| isImageScaleEnabled = !isImageScaleEnabled; |
| ptrViECodec->SetImageScaleStatus(videoChannel, isImageScaleEnabled); |
| if (isImageScaleEnabled) { |
| std::cout << "Image Scale is now enabled" << std::endl; |
| } else { |
| std::cout << "Image Scale is now disabled" << std::endl; |
| } |
| modify_call = true; |
| break; |
| default: |
| // invalid selection, shows options menu again |
| std::cout << "Invalid selection. Select Again." << std::endl; |
| break; |
| } |
| // modify_call is false if user does not select one of the |
| // modify options |
| if (modify_call == false) { |
| selection = 0; |
| } |
| } |
| // Stop the Call |
| std::cout << "Press enter to stop..."; |
| std::getline(std::cin, str); |
| //*************************************************************** |
| // Testing finished. Tear down Voice and Video Engine. |
| //*************************************************************** |
| // Tear down the VE first. |
| error = ptrVEBase->StopReceive(audioChannel); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| error = ptrVEBase->StopPlayout(audioChannel); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| error = ptrVEBase->DeleteChannel(audioChannel); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| // Now tear down the ViE engine. |
| error = ptrViEBase->DisconnectAudioChannel(videoChannel); |
| |
| // If Encoder/Decoder Observer is running, delete them. |
| if (codecEncoderObserver) { |
| error = ptrViECodec->DeregisterEncoderObserver(videoChannel); |
| delete codecEncoderObserver; |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| } |
| if (codecDecoderObserver) { |
| error = ptrViECodec->DeregisterDecoderObserver(videoChannel); |
| delete codecDecoderObserver; |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| } |
| |
| error = ptrViEBase->StopReceive(videoChannel); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| error = ptrViEBase->StopSend(videoChannel); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| error = ptrViERender->StopRender(captureId); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| error = ptrViERender->StopRender(videoChannel); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| error = ptrViERender->RemoveRenderer(captureId); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| error = ptrViERender->RemoveRenderer(videoChannel); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| error = ptrViECapture->StopCapture(captureId); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| error = ptrViECapture->DisconnectCaptureDevice(videoChannel); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| error = ptrViECapture->ReleaseCaptureDevice(captureId); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| error = ptrViEBase->DeleteChannel(videoChannel); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| int remainingInterfaces = 0; |
| remainingInterfaces = ptrViEFile->Release(); |
| numberOfErrors += ViETest::TestError(remainingInterfaces == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| remainingInterfaces = ptrViECodec->Release(); |
| numberOfErrors += ViETest::TestError(remainingInterfaces == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| remainingInterfaces = ptrViECapture->Release(); |
| numberOfErrors += ViETest::TestError(remainingInterfaces == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| remainingInterfaces = ptrViERtpRtcp->Release(); |
| numberOfErrors += ViETest::TestError(remainingInterfaces == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| remainingInterfaces = ptrViERender->Release(); |
| numberOfErrors += ViETest::TestError(remainingInterfaces == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| remainingInterfaces = ptrViENetwork->Release(); |
| numberOfErrors += ViETest::TestError(remainingInterfaces == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| remainingInterfaces = ptrViEBase->Release(); |
| numberOfErrors += ViETest::TestError(remainingInterfaces == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| bool deleted = webrtc::VideoEngine::Delete(ptrViE); |
| numberOfErrors += ViETest::TestError(deleted == true, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| ViETest::Log(" "); |
| ViETest::Log(" ViE Autotest Custom Call Started"); |
| ViETest::Log("========================================"); |
| ViETest::Log(" "); |
| } |
| return numberOfErrors; |
| } |
| |
| bool GetVideoDevice(webrtc::ViEBase* ptrViEBase, |
| webrtc::ViECapture* ptrViECapture, |
| char* captureDeviceName, |
| char* captureDeviceUniqueId) { |
| int error = 0; |
| int numberOfErrors = 0; |
| int captureDeviceIndex = 0; |
| std::string str; |
| |
| const unsigned int KMaxDeviceNameLength = 128; |
| const unsigned int KMaxUniqueIdLength = 256; |
| char deviceName[KMaxDeviceNameLength]; |
| char uniqueId[KMaxUniqueIdLength]; |
| |
| while (1) { |
| memset(deviceName, 0, KMaxDeviceNameLength); |
| memset(uniqueId, 0, KMaxUniqueIdLength); |
| |
| std::cout << std::endl; |
| std::cout << "Available video capture devices:" << std::endl; |
| int captureIdx = 0; |
| for (captureIdx = 0; |
| captureIdx < ptrViECapture->NumberOfCaptureDevices(); |
| captureIdx++) { |
| memset(deviceName, 0, KMaxDeviceNameLength); |
| memset(uniqueId, 0, KMaxUniqueIdLength); |
| |
| error = ptrViECapture->GetCaptureDevice(captureIdx, deviceName, |
| KMaxDeviceNameLength, |
| uniqueId, |
| KMaxUniqueIdLength); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| std::cout << " " << captureIdx+1 << ". " << deviceName |
| << "/" << uniqueId |
| << std::endl; |
| } |
| // Get the devName of the default (or first) camera for display. |
| error = ptrViECapture->GetCaptureDevice(0, deviceName, |
| KMaxDeviceNameLength, |
| uniqueId, |
| KMaxUniqueIdLength); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| std::cout << "Choose a video capture device. Press enter for default (" |
| << deviceName << "/" << uniqueId << "): "; |
| std::getline(std::cin, str); |
| captureDeviceIndex = atoi(str.c_str()); |
| |
| if (captureDeviceIndex == 0) { |
| // Use the default (or first) camera. |
| error = ptrViECapture->GetCaptureDevice(0, deviceName, |
| KMaxDeviceNameLength, |
| uniqueId, |
| KMaxUniqueIdLength); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| strcpy(captureDeviceUniqueId, uniqueId); |
| strcpy(captureDeviceName, deviceName); |
| return true; |
| } else if (captureDeviceIndex < 0 |
| || (captureDeviceIndex > |
| (int)ptrViECapture->NumberOfCaptureDevices())) { |
| // invalid selection |
| continue; |
| } else { |
| error = ptrViECapture->GetCaptureDevice(captureDeviceIndex - 1, |
| deviceName, |
| KMaxDeviceNameLength, |
| uniqueId, |
| KMaxUniqueIdLength); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| strcpy(captureDeviceUniqueId, uniqueId); |
| strcpy(captureDeviceName, deviceName); |
| return true; |
| } |
| } |
| } |
| |
| bool GetAudioDevices(webrtc::VoEBase* ptrVEBase, |
| webrtc::VoEHardware* ptrVEHardware, |
| char* recordingDeviceName, |
| int& recordingDeviceIndex, |
| char* playbackDeviceName, |
| int& playbackDeviceIndex) { |
| int error = 0; |
| int numberOfErrors = 0; |
| std::string str; |
| |
| const unsigned int KMaxDeviceNameLength = 128; |
| const unsigned int KMaxUniqueIdLength = 128; |
| char recordingDeviceUniqueName[KMaxDeviceNameLength]; |
| char playbackDeviceUniqueName[KMaxUniqueIdLength]; |
| |
| int numberOfRecordingDevices = -1; |
| error = ptrVEHardware->GetNumOfRecordingDevices(numberOfRecordingDevices); |
| numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| while (1) { |
| recordingDeviceIndex = -1; |
| std::cout << std::endl; |
| std::cout << "Available audio capture devices:" << std::endl; |
| int captureIdx = 0; |
| |
| for (captureIdx = 0; captureIdx < numberOfRecordingDevices; |
| captureIdx++) { |
| memset(recordingDeviceName, 0, KMaxDeviceNameLength); |
| memset(recordingDeviceUniqueName, 0, KMaxDeviceNameLength); |
| error = ptrVEHardware->GetRecordingDeviceName( |
| captureIdx, recordingDeviceName, recordingDeviceUniqueName); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| std::cout << " " << captureIdx+1 << ". " << recordingDeviceName |
| << std::endl; |
| } |
| |
| std::cout << "Choose an audio capture device. Press enter for default(" |
| << recordingDeviceName << "): "; |
| std::getline(std::cin, str); |
| int captureDeviceIndex = atoi(str.c_str()); |
| |
| if (captureDeviceIndex == 0) { |
| // Use the default (or first) recording device. |
| recordingDeviceIndex = 0; |
| error = ptrVEHardware->GetRecordingDeviceName( |
| recordingDeviceIndex, recordingDeviceName, |
| recordingDeviceUniqueName); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| break; |
| } else if (captureDeviceIndex < 0 |
| || captureDeviceIndex > numberOfRecordingDevices) { |
| // invalid selection |
| continue; |
| } else { |
| recordingDeviceIndex = captureDeviceIndex - 1; |
| error = ptrVEHardware->GetRecordingDeviceName( |
| recordingDeviceIndex, recordingDeviceName, |
| recordingDeviceUniqueName); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| break; |
| } |
| } |
| |
| int numberOfPlaybackDevices = -1; |
| error = ptrVEHardware->GetNumOfPlayoutDevices(numberOfPlaybackDevices); |
| numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| while (1) { |
| playbackDeviceIndex = -1; |
| std::cout << std::endl; |
| std::cout << "Available audio playout devices:" << std::endl; |
| int captureIdx = 0; |
| |
| for (captureIdx = 0; captureIdx < numberOfPlaybackDevices; |
| captureIdx++) { |
| memset(playbackDeviceName, 0, KMaxDeviceNameLength); |
| memset(playbackDeviceUniqueName, 0, KMaxDeviceNameLength); |
| error = ptrVEHardware->GetPlayoutDeviceName( |
| captureIdx, playbackDeviceName, playbackDeviceUniqueName); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| std::cout << " " << captureIdx+1 << ". " << playbackDeviceName |
| << std::endl; |
| } |
| |
| std::cout << |
| "Choose an audio playback device. Press enter for default (" |
| << playbackDeviceName << "): "; |
| std::getline(std::cin, str); |
| int captureDeviceIndex = atoi(str.c_str()); |
| |
| if (captureDeviceIndex == 0) { |
| // Use the default (or first) playout device. |
| playbackDeviceIndex = 0; |
| error = ptrVEHardware->GetPlayoutDeviceName( |
| playbackDeviceIndex, playbackDeviceName, |
| playbackDeviceUniqueName); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| return true; |
| } else if (captureDeviceIndex < 0 |
| || captureDeviceIndex > numberOfPlaybackDevices) { |
| // invalid selection |
| continue; |
| } else { |
| playbackDeviceIndex = captureDeviceIndex - 1; |
| error = ptrVEHardware->GetPlayoutDeviceName( |
| playbackDeviceIndex, playbackDeviceName, |
| playbackDeviceUniqueName); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| return true; |
| } |
| } |
| } |
| |
| // General helper functions. |
| |
| bool GetIPAddress(char* iIP) { |
| char oIP[16] = DEFAULT_SEND_IP; |
| std::string str; |
| |
| while (1) { |
| std::cout << std::endl; |
| std::cout << "Enter destination IP. Press enter for default (" |
| << oIP << "): "; |
| std::getline(std::cin, str); |
| |
| if (str.compare("") == 0) { |
| // use default value; |
| strcpy(iIP, oIP); |
| return true; |
| } |
| if (ValidateIP(str) == false) { |
| std::cout << "Invalid entry. Try again." << std::endl; |
| continue; |
| } |
| // done. Copy std::string to c_string and return |
| strcpy(iIP, str.c_str()); |
| return true; |
| } |
| assert(false); |
| return false; |
| } |
| |
| bool ValidateIP(std::string iStr) { |
| if (0 == iStr.compare("")) { |
| return false; |
| } |
| return true; |
| } |
| |
| // Video settings functions. |
| |
| bool SetVideoPorts(int* txPort, int* rxPort) { |
| std::string str; |
| int port = 0; |
| |
| // set to default values |
| *txPort = DEFAULT_VIDEO_PORT; |
| *rxPort = DEFAULT_VIDEO_PORT; |
| |
| while (1) { |
| std::cout << "Enter video send port. Press enter for default (" |
| << *txPort << "): "; |
| std::getline(std::cin, str); |
| port = atoi(str.c_str()); |
| |
| if (port == 0) { |
| // default value |
| break; |
| } else { |
| // user selection |
| if (port <= 0 || port > 63556) { |
| // invalid selection |
| continue; |
| } else { |
| *txPort = port; |
| break; // move on to rxport |
| } |
| } |
| } |
| |
| while (1) { |
| std::cout << "Enter video receive port. Press enter for default (" |
| << *rxPort << "): "; |
| std::getline(std::cin, str); |
| port = atoi(str.c_str()); |
| |
| if (port == 0) { |
| // default value |
| return true; |
| } else { |
| // user selection |
| if (port <= 0 || port > 63556) { |
| // invalid selection |
| continue; |
| } else { |
| *rxPort = port; |
| return true; |
| } |
| } |
| } |
| assert(false); |
| return false; |
| } |
| |
| // Audio settings functions. |
| |
| bool GetAudioPorts(int* txPort, int* rxPort) { |
| int port = 0; |
| std::string str; |
| |
| // set to default values |
| *txPort = DEFAULT_AUDIO_PORT; |
| *rxPort = DEFAULT_AUDIO_PORT; |
| |
| while (1) { |
| std::cout << "Enter audio send port. Press enter for default (" |
| << *txPort << "): "; |
| std::getline(std::cin, str); |
| port = atoi(str.c_str()); |
| |
| if (port == 0) { |
| // default value |
| break; |
| } else { |
| // user selection |
| if (port <= 0 || port > 63556) { |
| // invalid selection |
| continue; |
| } else { |
| *txPort = port; |
| break; // move on to rxport |
| } |
| } |
| } |
| |
| while (1) { |
| std::cout << "Enter audio receive port. Press enter for default (" |
| << *rxPort << "): "; |
| std::getline(std::cin, str); |
| port = atoi(str.c_str()); |
| |
| if (port == 0) { |
| // default value |
| return true; |
| } else { |
| // user selection |
| if (port <= 0 || port > 63556) { |
| // invalid selection |
| continue; |
| } else { |
| *rxPort = port; |
| return true; |
| } |
| } |
| } |
| assert(false); |
| return false; |
| } |
| |
| bool GetAudioCodec(webrtc::VoECodec* ptrVeCodec, |
| webrtc::CodecInst& audioCodec) { |
| int error = 0; |
| int numberOfErrors = 0; |
| int codecSelection = 0; |
| std::string str; |
| memset(&audioCodec, 0, sizeof(webrtc::CodecInst)); |
| |
| while (1) { |
| std::cout << std::endl; |
| std::cout << "Available audio codecs:" << std::endl; |
| int codecIdx = 0; |
| int defaultCodecIdx = 0; |
| for (codecIdx = 0; codecIdx < ptrVeCodec->NumOfCodecs(); codecIdx++) { |
| error = ptrVeCodec->GetCodec(codecIdx, audioCodec); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| |
| // test for default codec index |
| if (strcmp(audioCodec.plname, DEFAULT_AUDIO_CODEC) == 0) { |
| defaultCodecIdx = codecIdx; |
| } |
| std::cout << " " << codecIdx+1 << ". " << audioCodec.plname |
| << std::endl; |
| } |
| std::cout << std::endl; |
| std::cout << "Choose audio codec. Press enter for default (" |
| << DEFAULT_AUDIO_CODEC << "): "; |
| std::getline(std::cin, str); |
| codecSelection = atoi(str.c_str()); |
| |
| if (codecSelection == 0) { |
| // use default |
| error = ptrVeCodec->GetCodec(defaultCodecIdx, audioCodec); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| return true; |
| } else { |
| // user selection |
| codecSelection = atoi(str.c_str())-1; |
| error = ptrVeCodec->GetCodec(codecSelection, audioCodec); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| if (error != 0) { |
| std::cout << "ERROR: Code = " << error << " Invalid selection" |
| << std::endl; |
| continue; |
| } |
| return true; |
| } |
| } |
| assert(false); |
| return false; |
| } |
| |
| void PrintCallInformation(char* IP, char* videoCaptureDeviceName, |
| char* videoCaptureUniqueId, |
| webrtc::VideoCodec videoCodec, |
| int videoTxPort, int videoRxPort, |
| char* audioCaptureDeviceName, |
| char* audioPlaybackDeviceName, |
| webrtc::CodecInst audioCodec, |
| int audioTxPort, int audioRxPort, |
| int protectionMethod) { |
| std::string str; |
| |
| std::cout << "************************************************" |
| << std::endl; |
| std::cout << "The call has the following settings: " << std::endl; |
| std::cout << "\tIP: " << IP << std::endl; |
| std::cout << "\tVideo Capture Device: " << videoCaptureDeviceName |
| << std::endl; |
| std::cout << "\t\tName: " << videoCaptureDeviceName << std::endl; |
| std::cout << "\t\tUniqueId: " << videoCaptureUniqueId << std::endl; |
| PrintVideoCodec(videoCodec); |
| std::cout << "\t Video Tx Port: " << videoTxPort << std::endl; |
| std::cout << "\t Video Rx Port: " << videoRxPort << std::endl; |
| std::cout << "\t Video Protection Method: " << protectionMethod |
| << std::endl; |
| std::cout << "\tAudio Capture Device: " << audioCaptureDeviceName |
| << std::endl; |
| std::cout << "\tAudio Playback Device: " << audioPlaybackDeviceName |
| << std::endl; |
| std::cout << "\tAudio Codec: " << std::endl; |
| std::cout << "\t\tplname: " << audioCodec.plname << std::endl; |
| std::cout << "\t\tpltype: " << (int)audioCodec.pltype << std::endl; |
| std::cout << "\t Audio Tx Port: " << audioTxPort << std::endl; |
| std::cout << "\t Audio Rx Port: " << audioRxPort << std::endl; |
| std::cout << "************************************************" |
| << std::endl; |
| } |
| |
| bool SetVideoCodecType(webrtc::ViECodec* ptrViECodec, |
| webrtc::VideoCodec& videoCodec) { |
| int error = 0; |
| int numberOfErrors = 0; |
| int codecSelection = 0; |
| std::string str; |
| memset(&videoCodec, 0, sizeof(webrtc::VideoCodec)); |
| |
| bool exitLoop=false; |
| while (!exitLoop) { |
| std::cout << std::endl; |
| std::cout << "Available video codecs:" << std::endl; |
| int codecIdx = 0; |
| int defaultCodecIdx = 0; |
| // Print out all the codecs available to set Codec to. |
| for (codecIdx = 0; codecIdx < ptrViECodec->NumberOfCodecs(); codecIdx++) { |
| error = ptrViECodec->GetCodec(codecIdx, videoCodec); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| // test for default codec index |
| if (strcmp(videoCodec.plName, DEFAULT_VIDEO_CODEC) == 0) { |
| defaultCodecIdx = codecIdx; |
| } |
| std::cout << " " << codecIdx+1 << ". " << videoCodec.plName |
| << std::endl; |
| } |
| std::cout << std::endl; |
| std::cout << "Choose video codec. Press enter for default (" |
| << DEFAULT_VIDEO_CODEC << "): "; |
| std::getline(std::cin, str); |
| codecSelection = atoi(str.c_str()); |
| if (codecSelection == 0) { |
| // use default |
| error = ptrViECodec->GetCodec(defaultCodecIdx, videoCodec); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| exitLoop=true; |
| } else { |
| // user selection |
| codecSelection = atoi(str.c_str())-1; |
| error = ptrViECodec->GetCodec(codecSelection, videoCodec); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| if (error != 0) { |
| std::cout << "ERROR: Code=" << error << " Invalid selection" |
| << std::endl; |
| continue; |
| } |
| exitLoop=true; |
| } |
| } |
| if (videoCodec.codecType == webrtc::kVideoCodecI420) { |
| videoCodec.width = 176; |
| videoCodec.height = 144; |
| } |
| return true; |
| } |
| |
| bool SetVideoCodecResolution(webrtc::ViECodec* ptrViECodec, |
| webrtc::VideoCodec& videoCodec) { |
| std::string str; |
| int sizeOption = 5; |
| |
| if (videoCodec.codecType == webrtc::kVideoCodecVP8) { |
| std::cout << std::endl; |
| std::cout << "Available Common Resolutions : " << std::endl; |
| std::cout << " 1. SQCIF (128X96) " << std::endl; |
| std::cout << " 2. QQVGA (160X120) " << std::endl; |
| std::cout << " 3. QCIF (176X144) " << std::endl; |
| std::cout << " 4. CIF (352X288) " << std::endl; |
| std::cout << " 5. VGA (640X480) " << std::endl; |
| std::cout << " 6. WVGA (800x480) " << std::endl; |
| std::cout << " 7. 4CIF (704X576) " << std::endl; |
| std::cout << " 8. SVGA (800X600) " << std::endl; |
| std::cout << " 9. HD (1280X720) " << std::endl; |
| std::cout << " 10. XGA (1024x768) " << std::endl; |
| std::cout << "Enter frame size option: " << std::endl; |
| |
| std::getline(std::cin, str); |
| sizeOption = atoi(str.c_str()); |
| |
| switch (sizeOption) { |
| case 1: |
| videoCodec.width = 128; |
| videoCodec.height = 96; |
| break; |
| case 2: |
| videoCodec.width = 160; |
| videoCodec.height = 120; |
| break; |
| case 3: |
| videoCodec.width = 176; |
| videoCodec.height = 144; |
| break; |
| case 4: |
| videoCodec.width = 352; |
| videoCodec.height = 288; |
| break; |
| case 5: |
| videoCodec.width = 640; |
| videoCodec.height = 480; |
| break; |
| case 6: |
| videoCodec.width = 800; |
| videoCodec.height = 480; |
| break; |
| case 7: |
| videoCodec.width = 704; |
| videoCodec.height = 576; |
| break; |
| case 8: |
| videoCodec.width = 800; |
| videoCodec.height = 600; |
| break; |
| case 9: |
| videoCodec.width = 1280; |
| videoCodec.height = 720; |
| break; |
| case 10: |
| videoCodec.width = 1024; |
| videoCodec.height = 768; |
| break; |
| } |
| } else { |
| std::cout << "Can Only change codec size if it's VP8" << std::endl; |
| } |
| return true; |
| } |
| |
| bool SetVideoCodecSize(webrtc::ViECodec* ptrViECodec, |
| webrtc::VideoCodec& videoCodec) { |
| if (videoCodec.codecType == webrtc::kVideoCodecVP8) { |
| std::string str; |
| videoCodec.width = DEFAULT_VIDEO_CODEC_WIDTH; |
| videoCodec.height = DEFAULT_VIDEO_CODEC_HEIGHT; |
| std::cout << "Choose video width. Press enter for default (" |
| << DEFAULT_VIDEO_CODEC_WIDTH << "): "; |
| std::getline(std::cin, str); |
| int sizeSelection = atoi(str.c_str()); |
| if (sizeSelection!=0) { |
| videoCodec.width=sizeSelection; |
| } |
| std::cout << "Choose video height. Press enter for default (" |
| << DEFAULT_VIDEO_CODEC_HEIGHT << "): "; |
| std::getline(std::cin, str); |
| sizeSelection = atoi(str.c_str()); |
| if (sizeSelection!=0) { |
| videoCodec.height=sizeSelection; |
| } |
| } else { |
| std::cout << "Can Only change codec size if it's VP8" << std::endl; |
| } |
| return true; |
| } |
| |
| bool SetVideoCodecBitrate(webrtc::ViECodec* ptrViECodec, |
| webrtc::VideoCodec& videoCodec) { |
| std::string str; |
| std::cout << std::endl; |
| std::cout << "Choose start rate (in kbps). Press enter for default (" |
| << DEFAULT_VIDEO_CODEC_BITRATE << "): "; |
| std::getline(std::cin, str); |
| int startRate = atoi(str.c_str()); |
| videoCodec.startBitrate = DEFAULT_VIDEO_CODEC_BITRATE; |
| if (startRate != 0) { |
| videoCodec.startBitrate = startRate; |
| } |
| return true; |
| } |
| |
| bool SetVideoCodecMaxBitrate(webrtc::ViECodec* ptrViECodec, |
| webrtc::VideoCodec& videoCodec) { |
| std::string str; |
| std::cout << std::endl; |
| std::cout << "Choose max bitrate (in kbps). Press enter for default (" |
| << DEFAULT_VIDEO_CODEC_MAX_BITRATE << "): "; |
| std::getline(std::cin, str); |
| int maxRate = atoi(str.c_str()); |
| videoCodec.maxBitrate = DEFAULT_VIDEO_CODEC_MAX_BITRATE; |
| if (maxRate != 0) { |
| videoCodec.maxBitrate = maxRate; |
| } |
| return true; |
| } |
| |
| bool SetVideoCodecMinBitrate(webrtc::ViECodec* ptrViECodec, |
| webrtc::VideoCodec& videoCodec) { |
| std::string str; |
| std::cout << std::endl; |
| std::cout << "Choose min bitrate (in fps). Press enter for default (" |
| << DEFAULT_VIDEO_CODEC_MIN_BITRATE << "): "; |
| std::getline(std::cin, str); |
| char minBitRate = atoi(str.c_str()); |
| videoCodec.minBitrate = DEFAULT_VIDEO_CODEC_MIN_BITRATE; |
| if (minBitRate != 0) { |
| videoCodec.minBitrate = minBitRate; |
| } |
| return true; |
| } |
| |
| bool SetVideoCodecMaxFramerate(webrtc::ViECodec* ptrViECodec, |
| webrtc::VideoCodec& videoCodec) { |
| std::string str; |
| std::cout << std::endl; |
| std::cout << "Choose max framerate (in fps). Press enter for default (" |
| << DEFAULT_VIDEO_CODEC_MAX_FRAMERATE << "): "; |
| std::getline(std::cin, str); |
| char maxFrameRate = atoi(str.c_str()); |
| videoCodec.maxFramerate = DEFAULT_VIDEO_CODEC_MAX_FRAMERATE; |
| if (maxFrameRate != 0) { |
| videoCodec.maxFramerate = maxFrameRate; |
| } |
| return true; |
| } |
| |
| bool SetVideoCodecTemporalLayer(webrtc::VideoCodec& videoCodec) { |
| if (videoCodec.codecType == webrtc::kVideoCodecVP8) { |
| std::string str; |
| std::cout << std::endl; |
| std::cout << "Choose number of temporal layers (1 to 4). " |
| << "Press enter for default (" |
| << DEFAULT_TEMPORAL_LAYER << "): "; |
| std::getline(std::cin, str); |
| char numTemporalLayers = atoi(str.c_str()); |
| videoCodec.codecSpecific.VP8.numberOfTemporalLayers |
| = DEFAULT_TEMPORAL_LAYER; |
| if(numTemporalLayers != 0) { |
| videoCodec.codecSpecific.VP8.numberOfTemporalLayers |
| = numTemporalLayers; |
| } |
| } |
| return true; |
| } |
| // GetVideoProtection only prints the prompt to get a number |
| // that SetVideoProtection method uses |
| // 0 = None |
| // 1 = FEC |
| // 2 = NACK |
| // 3 = NACK + FEC (aka Hybrid) |
| // Default = DEFAULT_VIDEO_PROTECTION METHOD |
| int GetVideoProtection() { |
| int protectionMethod = DEFAULT_VIDEO_PROTECTION_METHOD; |
| |
| std::cout << "Available Video Protection Method." << std::endl; |
| std::cout << " 0. None" << std::endl; |
| std::cout << " 1. FEC" << std::endl; |
| std::cout << " 2. NACK" << std::endl; |
| std::cout << " 3. NACK+FEC" << std::endl; |
| std::cout << "Enter Video Protection Method. " |
| << "Press enter for default (" << protectionMethod << "):" |
| << std::endl; |
| std::string method; |
| std::getline(std::cin, method); |
| protectionMethod = atoi(method.c_str()); |
| |
| return protectionMethod; |
| } |
| |
| bool SetVideoProtection(webrtc::ViECodec* ptrViECodec, |
| webrtc::ViERTP_RTCP* ptrViERtpRtcp, |
| int videoChannel, int protectionMethod) { |
| int error = 0; |
| int numberOfErrors = 0; |
| webrtc::VideoCodec videoCodec; |
| |
| memset((void*)&videoCodec, 0, sizeof(webrtc::VideoCodec)); |
| |
| // Set all video protection to false initially |
| error = ptrViERtpRtcp->SetHybridNACKFECStatus(videoChannel, false, |
| VCM_RED_PAYLOAD_TYPE, |
| VCM_ULPFEC_PAYLOAD_TYPE); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| error = ptrViERtpRtcp->SetFECStatus(videoChannel, false, |
| VCM_RED_PAYLOAD_TYPE, |
| VCM_ULPFEC_PAYLOAD_TYPE); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| error = ptrViERtpRtcp->SetNACKStatus(videoChannel, false); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| // Set video protection for FEC, NACK or Hybrid |
| switch (protectionMethod) { |
| case 0: // None |
| // No protection selected, all protection already at false |
| std::cout << "Call using None protection Method" |
| << std::endl; |
| break; |
| case 1: // FEC only |
| std::cout << "Call using FEC protection Method" |
| << std::endl; |
| error = ptrViERtpRtcp->SetFECStatus(videoChannel, true, |
| VCM_RED_PAYLOAD_TYPE, |
| VCM_ULPFEC_PAYLOAD_TYPE); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| break; |
| case 2: // NACK only |
| std::cout << "Call using NACK protection Method" |
| << std::endl; |
| error = ptrViERtpRtcp->SetNACKStatus(videoChannel, true); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| break; |
| case 3: // Hybrid NACK and FEC |
| std::cout << "Call using Hybrid NACK and FEC protection Method" |
| << std::endl; |
| error = ptrViERtpRtcp->SetHybridNACKFECStatus(videoChannel, true, |
| VCM_RED_PAYLOAD_TYPE, |
| VCM_ULPFEC_PAYLOAD_TYPE); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| break; |
| } |
| |
| // Set receive codecs for FEC and hybrid NACK/FEC |
| if (protectionMethod == 1 || protectionMethod == 3) { |
| // RED |
| error = ptrViECodec->GetCodec(ptrViECodec->NumberOfCodecs() - 2, |
| videoCodec); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| videoCodec.plType = VCM_RED_PAYLOAD_TYPE; |
| error = ptrViECodec->SetReceiveCodec(videoChannel, videoCodec); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| std::cout << "RED Codec Information:" << std::endl; |
| PrintVideoCodec(videoCodec); |
| // ULPFEC |
| error = ptrViECodec->GetCodec(ptrViECodec->NumberOfCodecs() - 1, |
| videoCodec); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| videoCodec.plType = VCM_ULPFEC_PAYLOAD_TYPE; |
| error = ptrViECodec->SetReceiveCodec(videoChannel, videoCodec); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| std::cout << "ULPFEC Codec Information:" << std::endl; |
| PrintVideoCodec(videoCodec); |
| } |
| |
| |
| |
| return true; |
| } |
| |
| bool GetBitrateSignaling() { |
| std::cout << std::endl; |
| std::cout << "Available bitrate signaling methods." << std::endl; |
| std::cout << " 0. REMB" << std::endl; |
| std::cout << " 1. TMMBR" << std::endl; |
| std::cout << "Enter bitrate signaling methods. " |
| << "Press enter for default (REMB): " << std::endl; |
| std::string method; |
| std::getline(std::cin, method); |
| if (atoi(method.c_str()) == 1) { |
| return false; |
| } |
| return true; |
| } |
| |
| void PrintRTCCPStatistics(webrtc::ViERTP_RTCP* ptrViERtpRtcp, |
| int videoChannel, StatisticsType statType) { |
| int error = 0; |
| int numberOfErrors =0; |
| unsigned short fractionLost = 0; |
| unsigned int cumulativeLost = 0; |
| unsigned int extendedMax = 0; |
| unsigned int jitter = 0; |
| int rttMS = 0; |
| |
| switch (statType) { |
| case kReceivedStatistic: |
| std::cout << "RTCP Received statistics" |
| << std::endl; |
| // Get and print the Received RTCP Statistics |
| error = ptrViERtpRtcp->GetReceivedRTCPStatistics(videoChannel, |
| fractionLost, |
| cumulativeLost, |
| extendedMax, |
| jitter, rttMS); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| break; |
| case kSendStatistic: |
| std::cout << "RTCP Sent statistics" |
| << std::endl; |
| // Get and print the Sent RTCP Statistics |
| error = ptrViERtpRtcp->GetSentRTCPStatistics(videoChannel, fractionLost, |
| cumulativeLost, extendedMax, |
| jitter, rttMS); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| break; |
| } |
| std::cout << "\tRTCP fraction of lost packets: " |
| << fractionLost << std::endl; |
| std::cout << "\tRTCP cumulative number of lost packets: " |
| << cumulativeLost << std::endl; |
| std::cout << "\tRTCP max received sequence number " |
| << extendedMax << std::endl; |
| std::cout << "\tRTCP jitter: " |
| << jitter << std::endl; |
| std::cout << "\tRTCP round trip (ms): " |
| << rttMS<< std::endl; |
| } |
| |
| void PrintRTPStatistics(webrtc::ViERTP_RTCP* ptrViERtpRtcp, |
| int videoChannel) { |
| int error = 0; |
| int numberOfErrors =0; |
| unsigned int bytesSent = 0; |
| unsigned int packetsSent= 0; |
| unsigned int bytesReceived = 0; |
| unsigned int packetsReceived = 0; |
| |
| std::cout << "RTP statistics" |
| << std::endl; |
| |
| // Get and print the RTP Statistics |
| error = ptrViERtpRtcp->GetRTPStatistics(videoChannel, bytesSent, packetsSent, |
| bytesReceived, packetsReceived); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| std::cout << "\tRTP bytes sent: " |
| << bytesSent << std::endl; |
| std::cout << "\tRTP packets sent: " |
| << packetsSent << std::endl; |
| std::cout << "\tRTP bytes received: " |
| << bytesReceived << std::endl; |
| std::cout << "\tRTP packets received: " |
| << packetsReceived << std::endl; |
| } |
| |
| void PrintBandwidthUsage(webrtc::ViERTP_RTCP* ptrViERtpRtcp, |
| int videoChannel) { |
| int error = 0; |
| int numberOfErrors = 0; |
| unsigned int totalBitrateSent = 0; |
| unsigned int videoBitrateSent = 0; |
| unsigned int fecBitrateSent = 0; |
| unsigned int nackBitrateSent = 0; |
| double percentageFEC = 0; |
| double percentageNACK = 0; |
| |
| std::cout << "Bandwidth Usage" |
| << std::endl; |
| |
| // Get and print Bandwidth usage |
| error = ptrViERtpRtcp->GetBandwidthUsage(videoChannel, totalBitrateSent, |
| videoBitrateSent, fecBitrateSent, |
| nackBitrateSent); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| std::cout << "\tTotal bitrate sent (Kbit/s): " |
| << totalBitrateSent << std::endl; |
| std::cout << "\tVideo bitrate sent (Kbit/s): " |
| << videoBitrateSent << std::endl; |
| std::cout << "\tFEC bitrate sent (Kbit/s): " |
| << fecBitrateSent << std::endl; |
| percentageFEC = ((double)fecBitrateSent/(double)totalBitrateSent) * 100; |
| std::cout << "\tPercentage FEC bitrate sent from total bitrate: " |
| << percentageFEC << std::endl; |
| std::cout << "\tNACK bitrate sent (Kbit/s): " |
| << nackBitrateSent << std::endl; |
| percentageNACK = ((double)nackBitrateSent/(double)totalBitrateSent) * 100; |
| std::cout << "\tPercentage NACK bitrate sent from total bitrate: " |
| << percentageNACK << std::endl; |
| } |
| |
| void PrintCodecStatistics(webrtc::ViECodec* ptrViECodec, int videoChannel, |
| StatisticsType statType) { |
| int error = 0; |
| int numberOfErrors = 0; |
| unsigned int keyFrames = 0; |
| unsigned int deltaFrames = 0; |
| switch(statType) { |
| case kReceivedStatistic: |
| std::cout << "Codec Receive statistics" |
| << std::endl; |
| // Get and print the Receive Codec Statistics |
| error = ptrViECodec->GetReceiveCodecStastistics(videoChannel, keyFrames, |
| deltaFrames); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| break; |
| case kSendStatistic: |
| std::cout << "Codec Send statistics" |
| << std::endl; |
| // Get and print the Send Codec Statistics |
| error = ptrViECodec->GetSendCodecStastistics(videoChannel, keyFrames, |
| deltaFrames); |
| numberOfErrors += ViETest::TestError(error == 0, |
| "ERROR: %s at line %d", |
| __FUNCTION__, __LINE__); |
| break; |
| } |
| std::cout << "\tNumber of encoded key frames: " |
| << keyFrames << std::endl; |
| std::cout << "\tNumber of encoded delta frames: " |
| << deltaFrames << std::endl; |
| } |
| |
| void PrintGetDiscardedPackets(webrtc::ViECodec* ptrViECodec, int videoChannel) { |
| std::cout << "Discarded Packets" |
| << std::endl; |
| int discardedPackets = 0; |
| discardedPackets = ptrViECodec->GetDiscardedPackets(videoChannel); |
| std::cout << "\tNumber of discarded packets: " |
| << discardedPackets << std::endl; |
| } |
| |
| void PrintVideoStreamInformation(webrtc::ViECodec* ptrViECodec, |
| int videoChannel) { |
| webrtc::VideoCodec outgoingCodec; |
| webrtc::VideoCodec incomingCodec; |
| |
| memset((void*)&outgoingCodec, 0, sizeof(webrtc::VideoCodec)); |
| memset((void*)&incomingCodec, 0, sizeof(webrtc::VideoCodec)); |
| |
| ptrViECodec->GetSendCodec(videoChannel, outgoingCodec); |
| ptrViECodec->GetReceiveCodec(videoChannel, incomingCodec); |
| |
| std::cout << "************************************************" |
| << std::endl; |
| std::cout << "ChannelId: " << videoChannel << std::endl; |
| std::cout << "Outgoing Stream information:" <<std::endl; |
| PrintVideoCodec(outgoingCodec); |
| std::cout << "Incoming Stream information:" <<std::endl; |
| PrintVideoCodec(incomingCodec); |
| std::cout << "************************************************" |
| << std::endl; |
| } |
| |
| void PrintVideoCodec(webrtc::VideoCodec videoCodec) { |
| std::cout << "\t\tplName: " << videoCodec.plName << std::endl; |
| std::cout << "\t\tplType: " << (int)videoCodec.plType << std::endl; |
| std::cout << "\t\twidth: " << videoCodec.width << std::endl; |
| std::cout << "\t\theight: " << videoCodec.height << std::endl; |
| std::cout << "\t\tstartBitrate: " << videoCodec.startBitrate |
| << std::endl; |
| std::cout << "\t\tminBitrate: " << videoCodec.minBitrate |
| << std::endl; |
| std::cout << "\t\tmaxBitrate: " << videoCodec.maxBitrate |
| << std::endl; |
| std::cout << "\t\tmaxFramerate: " << (int)videoCodec.maxFramerate |
| << std::endl; |
| if (videoCodec.codecType == webrtc::kVideoCodecVP8) { |
| std::cout << "\t\tVP8 Temporal Layer: " |
| << (int)videoCodec.codecSpecific.VP8.numberOfTemporalLayers |
| << std::endl; |
| } |
| } |
