| /* |
| * 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 "vie_autotest.h" |
| |
| #include "codec_primitives.h" |
| #include "common_types.h" |
| #include "general_primitives.h" |
| #include "tb_capture_device.h" |
| #include "tb_I420_codec.h" |
| #include "tb_interfaces.h" |
| #include "tb_video_channel.h" |
| #include "vie_autotest_defines.h" |
| |
| class RenderFilter : public webrtc::ViEEffectFilter { |
| public: |
| RenderFilter() |
| : last_render_width_(0), |
| last_render_height_(0) {} |
| |
| ~RenderFilter() {} |
| |
| virtual int Transform(int size, unsigned char* frame_buffer, |
| unsigned int time_stamp, unsigned int width, |
| unsigned int height) { |
| last_render_width_ = width; |
| last_render_height_ = height; |
| return 0; |
| } |
| unsigned int last_render_width_; |
| unsigned int last_render_height_; |
| }; |
| |
| void ViEAutoTest::ViECodecStandardTest() |
| { |
| TbInterfaces interfaces = TbInterfaces("ViECodecStandardTest"); |
| TbCaptureDevice capture_device = TbCaptureDevice(interfaces); |
| |
| int video_channel = -1; |
| |
| EXPECT_EQ(0, interfaces.base->CreateChannel(video_channel)); |
| EXPECT_EQ(0, interfaces.capture->ConnectCaptureDevice( |
| capture_device.captureId, video_channel)); |
| |
| ConfigureRtpRtcp(interfaces.rtp_rtcp, |
| video_channel); |
| |
| RenderInWindow(interfaces.render, capture_device.captureId, _window1, 0); |
| RenderInWindow(interfaces.render, video_channel, _window2, 1); |
| |
| TestCodecs(interfaces, capture_device.captureId, video_channel, |
| kDoNotForceResolution, kDoNotForceResolution); |
| } |
| |
| void ViEAutoTest::ViECodecExtendedTest() |
| { |
| { |
| ViECodecAPITest(); |
| ViECodecStandardTest(); |
| ViECodecExternalCodecTest(); |
| |
| TbInterfaces interfaces = TbInterfaces("ViECodecExtendedTest"); |
| webrtc::ViEBase* ptrViEBase = interfaces.base; |
| webrtc::ViECapture* ptrViECapture = interfaces.capture; |
| webrtc::ViERender* ptrViERender = interfaces.render; |
| webrtc::ViECodec* ptrViECodec = interfaces.codec; |
| webrtc::ViERTP_RTCP* ptrViERtpRtcp = interfaces.rtp_rtcp; |
| webrtc::ViENetwork* ptrViENetwork = interfaces.network; |
| |
| TbCaptureDevice captureDevice = TbCaptureDevice(interfaces); |
| int captureId = captureDevice.captureId; |
| |
| int videoChannel = -1; |
| EXPECT_EQ(0, ptrViEBase->CreateChannel(videoChannel)); |
| EXPECT_EQ(0, ptrViECapture->ConnectCaptureDevice( |
| captureId, videoChannel)); |
| |
| EXPECT_EQ(0, ptrViERtpRtcp->SetRTCPStatus( |
| videoChannel, webrtc::kRtcpCompound_RFC4585)); |
| EXPECT_EQ(0, ptrViERtpRtcp->SetKeyFrameRequestMethod( |
| videoChannel, webrtc::kViEKeyFrameRequestPliRtcp)); |
| EXPECT_EQ(0, ptrViERtpRtcp->SetTMMBRStatus(videoChannel, true)); |
| EXPECT_EQ(0, ptrViERender->AddRenderer( |
| captureId, _window1, 0, 0.0, 0.0, 1.0, 1.0)); |
| EXPECT_EQ(0, ptrViERender->AddRenderer( |
| videoChannel, _window2, 1, 0.0, 0.0, 1.0, 1.0)); |
| EXPECT_EQ(0, ptrViERender->StartRender(captureId)); |
| EXPECT_EQ(0, ptrViERender->StartRender(videoChannel)); |
| |
| webrtc::VideoCodec videoCodec; |
| memset(&videoCodec, 0, sizeof(webrtc::VideoCodec)); |
| for (int idx = 0; idx < ptrViECodec->NumberOfCodecs(); idx++) |
| { |
| EXPECT_EQ(0, ptrViECodec->GetCodec(idx, videoCodec)); |
| |
| if (videoCodec.codecType != webrtc::kVideoCodecI420) |
| { |
| videoCodec.width = 640; |
| videoCodec.height = 480; |
| } |
| EXPECT_EQ(0, ptrViECodec->SetReceiveCodec( |
| videoChannel, videoCodec)); |
| } |
| |
| const char* ipAddress = "127.0.0.1"; |
| const unsigned short rtpPort = 6000; |
| EXPECT_EQ(0, ptrViENetwork->SetLocalReceiver(videoChannel, rtpPort)); |
| EXPECT_EQ(0, ptrViEBase->StartReceive(videoChannel)); |
| EXPECT_EQ(0, ptrViENetwork->SetSendDestination( |
| videoChannel, ipAddress, rtpPort)); |
| EXPECT_EQ(0, ptrViEBase->StartSend(videoChannel)); |
| |
| // |
| // Codec specific tests |
| // |
| memset(&videoCodec, 0, sizeof(webrtc::VideoCodec)); |
| EXPECT_EQ(0, ptrViEBase->StopSend(videoChannel)); |
| ViEAutotestCodecObserver codecObserver; |
| EXPECT_EQ(0, ptrViECodec->RegisterEncoderObserver( |
| videoChannel, codecObserver)); |
| EXPECT_EQ(0, ptrViECodec->RegisterDecoderObserver( |
| videoChannel, codecObserver)); |
| |
| EXPECT_EQ(0, ptrViEBase->StopReceive(videoChannel)); |
| EXPECT_NE(0, ptrViEBase->StopSend(videoChannel)); // Already stopped |
| |
| EXPECT_EQ(0, ptrViERender->StopRender(videoChannel)); |
| EXPECT_EQ(0, ptrViERender->RemoveRenderer(captureId)); |
| EXPECT_EQ(0, ptrViERender->RemoveRenderer(videoChannel)); |
| EXPECT_EQ(0, ptrViECapture->DisconnectCaptureDevice(videoChannel)); |
| EXPECT_EQ(0, ptrViEBase->DeleteChannel(videoChannel)); |
| } |
| |
| // |
| // Default channel |
| // |
| { |
| // Create VIE |
| TbInterfaces ViE("ViECodecExtendedTest2"); |
| // Create a capture device |
| TbCaptureDevice tbCapture(ViE); |
| |
| // Create channel 1 |
| int videoChannel1 = -1; |
| EXPECT_EQ(0, ViE.base->CreateChannel(videoChannel1)); |
| |
| unsigned short rtpPort1 = 12000; |
| EXPECT_EQ(0, ViE.network->SetLocalReceiver( |
| videoChannel1, rtpPort1)); |
| EXPECT_EQ(0, ViE.network->SetSendDestination( |
| videoChannel1, "127.0.0.1", rtpPort1)); |
| tbCapture.ConnectTo(videoChannel1); |
| |
| EXPECT_EQ(0, ViE.rtp_rtcp->SetKeyFrameRequestMethod( |
| videoChannel1, webrtc::kViEKeyFrameRequestPliRtcp)); |
| EXPECT_EQ(0, ViE.render->AddRenderer( |
| videoChannel1, _window1, 0, 0.0, 0.0, 1.0, 1.0)); |
| EXPECT_EQ(0, ViE.render->StartRender(videoChannel1)); |
| |
| ViEAutotestCodecObserver codecObserver1; |
| EXPECT_EQ(0, ViE.codec->RegisterEncoderObserver( |
| videoChannel1, codecObserver1)); |
| EXPECT_EQ(0, ViE.codec->RegisterDecoderObserver( |
| videoChannel1, codecObserver1)); |
| |
| // Set Send codec |
| unsigned short codecWidth = 176; |
| unsigned short codecHeight = 144; |
| bool codecSet = false; |
| webrtc::VideoCodec videoCodec; |
| for (int idx = 0; idx < ViE.codec->NumberOfCodecs(); idx++) |
| { |
| EXPECT_EQ(0, ViE.codec->GetCodec(idx, videoCodec)); |
| EXPECT_EQ(0, ViE.codec->SetReceiveCodec(videoChannel1, videoCodec)); |
| if (videoCodec.codecType == webrtc::kVideoCodecVP8) |
| { |
| videoCodec.width = codecWidth; |
| videoCodec.height = codecHeight; |
| videoCodec.startBitrate = 200; |
| videoCodec.maxBitrate = 300; |
| EXPECT_EQ(0, ViE.codec->SetSendCodec( |
| videoChannel1, videoCodec)); |
| codecSet = true; |
| break; |
| } |
| } |
| EXPECT_TRUE(codecSet); |
| webrtc::VideoCodec send_codec; |
| memcpy(&send_codec, &videoCodec, sizeof(videoCodec)); |
| |
| EXPECT_EQ(0, ViE.base->StartSend(videoChannel1)); |
| EXPECT_EQ(0, ViE.base->StartReceive(videoChannel1)); |
| |
| // Create channel 2, based on channel 1 |
| int videoChannel2 = -1; |
| EXPECT_EQ(0, ViE.base->CreateChannel(videoChannel2, videoChannel1)); |
| EXPECT_NE(videoChannel1, videoChannel2) << |
| "Channel 2 should be seop"; |
| |
| EXPECT_EQ(0, ViE.rtp_rtcp->SetKeyFrameRequestMethod( |
| videoChannel2, webrtc::kViEKeyFrameRequestPliRtcp)); |
| |
| // Prepare receive codecs |
| for (int idx = 0; idx < ViE.codec->NumberOfCodecs(); idx++) |
| { |
| EXPECT_EQ(0, ViE.codec->GetCodec(idx, videoCodec)); |
| EXPECT_EQ(0, ViE.codec->SetReceiveCodec(videoChannel2, videoCodec)); |
| } |
| |
| ViEAutotestCodecObserver codecObserver2; |
| EXPECT_EQ(0, ViE.codec->RegisterDecoderObserver( |
| videoChannel2, codecObserver2)); |
| EXPECT_EQ(0, ViE.render->AddRenderer( |
| videoChannel2, _window2, 0, 0.0, 0.0, 1.0, 1.0)); |
| EXPECT_EQ(0, ViE.render->StartRender(videoChannel2)); |
| |
| unsigned short rtpPort2 = 13000; |
| EXPECT_EQ(0, ViE.network->SetLocalReceiver(videoChannel2, rtpPort2)); |
| EXPECT_EQ(0, ViE.network->SetSendDestination( |
| videoChannel2, "127.0.0.1", rtpPort2)); |
| |
| EXPECT_EQ(0, ViE.base->StartReceive(videoChannel2)); |
| EXPECT_EQ(0, ViE.base->StartSend(videoChannel2)); |
| |
| ViETest::Log("\nTest using one encoder on several channels"); |
| ViETest::Log("Channel 1 is rendered in Window1, channel 2 in Window 2." |
| "\nSending VP8 on both channels"); |
| |
| AutoTestSleep(KAutoTestSleepTimeMs); |
| |
| EXPECT_EQ(webrtc::kVideoCodecVP8, |
| codecObserver1.incomingCodec.codecType); |
| EXPECT_EQ(send_codec.width, codecObserver1.incomingCodec.width); |
| EXPECT_EQ(webrtc::kVideoCodecVP8, |
| codecObserver2.incomingCodec.codecType); |
| EXPECT_EQ(send_codec.width, codecObserver2.incomingCodec.width); |
| |
| // Change resolution on one of the channels and verify it changes for |
| // the other channel too. |
| send_codec.width = 2 * codecWidth; |
| send_codec.height = 2 * codecHeight; |
| EXPECT_EQ(0, ViE.codec->SetSendCodec(videoChannel1, send_codec)); |
| |
| // We need to verify using render effect filter since we won't trigger |
| // a decode reset in loopback (due to using the same SSRC). |
| RenderFilter filter1; |
| RenderFilter filter2; |
| EXPECT_EQ(0, |
| ViE.image_process->RegisterRenderEffectFilter(videoChannel1, |
| filter1)); |
| EXPECT_EQ(0, |
| ViE.image_process->RegisterRenderEffectFilter(videoChannel2, |
| filter2)); |
| |
| AutoTestSleep(KAutoTestSleepTimeMs); |
| |
| EXPECT_EQ(0, ViE.image_process->DeregisterRenderEffectFilter( |
| videoChannel1)); |
| EXPECT_EQ(0, ViE.image_process->DeregisterRenderEffectFilter( |
| videoChannel2)); |
| EXPECT_EQ(send_codec.width, filter1.last_render_width_); |
| EXPECT_EQ(send_codec.height, filter1.last_render_height_); |
| EXPECT_EQ(send_codec.width, filter2.last_render_width_); |
| EXPECT_EQ(send_codec.height, filter2.last_render_height_); |
| |
| // Delete the first channel and keep the second |
| EXPECT_EQ(0, ViE.base->DeleteChannel(videoChannel1)); |
| ViETest::Log("Channel 1 deleted, " |
| "you should only see video in Window 2"); |
| |
| AutoTestSleep(KAutoTestSleepTimeMs); |
| |
| // Create another channel |
| int videoChannel3 = -1; |
| EXPECT_EQ(0, ViE.base->CreateChannel(videoChannel3, videoChannel2)); |
| EXPECT_NE(videoChannel3, videoChannel2); |
| |
| EXPECT_EQ(0, ViE.rtp_rtcp->SetKeyFrameRequestMethod( |
| videoChannel3, webrtc::kViEKeyFrameRequestPliRtcp)); |
| |
| // Prepare receive codecs |
| for (int idx = 0; idx < ViE.codec->NumberOfCodecs(); idx++) |
| { |
| EXPECT_EQ(0, ViE.codec->GetCodec(idx, videoCodec)); |
| EXPECT_EQ(0, ViE.codec->SetReceiveCodec( |
| videoChannel3, videoCodec)); |
| } |
| |
| ViEAutotestCodecObserver codecObserver3; |
| EXPECT_EQ(0, ViE.codec->RegisterDecoderObserver( |
| videoChannel3, codecObserver3)); |
| |
| EXPECT_EQ(0, ViE.render->AddRenderer( |
| videoChannel3, _window1, 0, 0.0, 0.0, 1.0, 1.0)); |
| EXPECT_EQ(0, ViE.render->StartRender(videoChannel3)); |
| |
| unsigned short rtpPort3 = 14000; |
| EXPECT_EQ(0, ViE.network->SetLocalReceiver(videoChannel3, rtpPort3)); |
| EXPECT_EQ(0, ViE.network->SetSendDestination( |
| videoChannel3, "127.0.0.1", rtpPort3)); |
| |
| EXPECT_EQ(0, ViE.base->StartReceive(videoChannel3)); |
| EXPECT_EQ(0, ViE.base->StartSend(videoChannel3)); |
| |
| EXPECT_EQ(0, ViE.base->DeleteChannel(videoChannel2)); |
| |
| ViETest::Log("A third channel created and rendered in Window 1,\n" |
| "channel 2 is deleted and you should only see video in Window 1"); |
| |
| AutoTestSleep(KAutoTestSleepTimeMs); |
| |
| EXPECT_EQ(0, ViE.base->DeleteChannel(videoChannel3)); |
| } |
| } |
| |
| void ViEAutoTest::ViECodecAPITest() |
| { |
| // *************************************************************** |
| // Begin create/initialize WebRTC Video Engine for testing |
| // *************************************************************** |
| webrtc::VideoEngine* ptrViE = NULL; |
| ptrViE = webrtc::VideoEngine::Create(); |
| EXPECT_TRUE(ptrViE != NULL); |
| |
| webrtc::ViEBase* ptrViEBase = webrtc::ViEBase::GetInterface(ptrViE); |
| EXPECT_TRUE(ptrViEBase != NULL); |
| |
| EXPECT_EQ(0, ptrViEBase->Init()); |
| |
| int videoChannel = -1; |
| EXPECT_EQ(0, ptrViEBase->CreateChannel(videoChannel)); |
| |
| webrtc::ViECodec* ptrViECodec = webrtc::ViECodec::GetInterface(ptrViE); |
| EXPECT_TRUE(ptrViECodec != NULL); |
| |
| //*************************************************************** |
| // Engine ready. Begin testing class |
| //*************************************************************** |
| |
| // |
| // SendCodec |
| // |
| webrtc::VideoCodec videoCodec; |
| memset(&videoCodec, 0, sizeof(webrtc::VideoCodec)); |
| |
| const int numberOfCodecs = ptrViECodec->NumberOfCodecs(); |
| EXPECT_GT(numberOfCodecs, 0); |
| |
| SetSendCodec(webrtc::kVideoCodecVP8, ptrViECodec, videoChannel, |
| kDoNotForceResolution, kDoNotForceResolution); |
| |
| memset(&videoCodec, 0, sizeof(videoCodec)); |
| EXPECT_EQ(0, ptrViECodec->GetSendCodec(videoChannel, videoCodec)); |
| EXPECT_EQ(webrtc::kVideoCodecVP8, videoCodec.codecType); |
| |
| SetSendCodec(webrtc::kVideoCodecI420, ptrViECodec, videoChannel, |
| kDoNotForceResolution, kDoNotForceResolution); |
| memset(&videoCodec, 0, sizeof(videoCodec)); |
| EXPECT_EQ(0, ptrViECodec->GetSendCodec(videoChannel, videoCodec)); |
| EXPECT_EQ(webrtc::kVideoCodecI420, videoCodec.codecType); |
| |
| //*************************************************************** |
| // Testing finished. Tear down Video Engine |
| //*************************************************************** |
| |
| EXPECT_EQ(0, ptrViEBase->DeleteChannel(videoChannel)); |
| |
| EXPECT_EQ(0, ptrViECodec->Release()); |
| EXPECT_EQ(0, ptrViEBase->Release()); |
| EXPECT_TRUE(webrtc::VideoEngine::Delete(ptrViE)); |
| } |
| |
| #ifdef WEBRTC_VIDEO_ENGINE_EXTERNAL_CODEC_API |
| #include "vie_external_codec.h" |
| #endif |
| void ViEAutoTest::ViECodecExternalCodecTest() |
| { |
| // *************************************************************** |
| // Begin create/initialize WebRTC Video Engine for testing |
| // *************************************************************** |
| |
| |
| // *************************************************************** |
| // Engine ready. Begin testing class |
| // *************************************************************** |
| |
| #ifdef WEBRTC_VIDEO_ENGINE_EXTERNAL_CODEC_API |
| { |
| TbInterfaces ViE("ViEExternalCodec"); |
| TbCaptureDevice captureDevice(ViE); |
| TbVideoChannel channel( |
| ViE, webrtc::kVideoCodecI420, 352,288,30,(352*288*3*8*30)/(2*1000)); |
| |
| captureDevice.ConnectTo(channel.videoChannel); |
| |
| EXPECT_EQ(0, ViE.render->AddRenderer( |
| channel.videoChannel, _window1, 0, 0.0, 0.0, 1.0, 1.0)); |
| EXPECT_EQ(0, ViE.render->StartRender(channel.videoChannel)); |
| |
| channel.StartReceive(); |
| channel.StartSend(); |
| |
| ViETest::Log("Using internal I420 codec"); |
| AutoTestSleep(KAutoTestSleepTimeMs/2); |
| |
| webrtc::ViEExternalCodec* ptrViEExtCodec = |
| webrtc::ViEExternalCodec::GetInterface(ViE.video_engine); |
| EXPECT_TRUE(ptrViEExtCodec != NULL); |
| |
| webrtc::VideoCodec codecStruct; |
| |
| EXPECT_EQ(0, ViE.codec->GetSendCodec( |
| channel.videoChannel, codecStruct)); |
| |
| // Use external encoder instead |
| { |
| TbI420Encoder extEncoder; |
| |
| // Test to register on wrong channel |
| EXPECT_NE(0, ptrViEExtCodec->RegisterExternalSendCodec( |
| channel.videoChannel+5,codecStruct.plType,&extEncoder)); |
| EXPECT_EQ(kViECodecInvalidArgument, ViE.LastError()); |
| |
| EXPECT_EQ(0, ptrViEExtCodec->RegisterExternalSendCodec( |
| channel.videoChannel,codecStruct.plType,&extEncoder)); |
| |
| // Use new external encoder |
| EXPECT_EQ(0, ViE.codec->SetSendCodec( |
| channel.videoChannel, codecStruct)); |
| |
| TbI420Decoder extDecoder; |
| EXPECT_EQ(0, ptrViEExtCodec->RegisterExternalReceiveCodec( |
| channel.videoChannel,codecStruct.plType,&extDecoder)); |
| |
| EXPECT_EQ(0, ViE.codec->SetReceiveCodec( |
| channel.videoChannel, codecStruct)); |
| |
| ViETest::Log("Using external I420 codec"); |
| AutoTestSleep(KAutoTestSleepTimeMs); |
| |
| // Test to deregister on wrong channel |
| EXPECT_NE(0, ptrViEExtCodec->DeRegisterExternalSendCodec( |
| channel.videoChannel+5,codecStruct.plType)); |
| EXPECT_EQ(kViECodecInvalidArgument, ViE.LastError()); |
| |
| // Test to deregister wrong payload type. |
| EXPECT_NE(0, ptrViEExtCodec->DeRegisterExternalSendCodec( |
| channel.videoChannel,codecStruct.plType-1)); |
| |
| // Deregister external send codec |
| EXPECT_EQ(0, ptrViEExtCodec->DeRegisterExternalSendCodec( |
| channel.videoChannel,codecStruct.plType)); |
| |
| EXPECT_EQ(0, ptrViEExtCodec->DeRegisterExternalReceiveCodec( |
| channel.videoChannel,codecStruct.plType)); |
| |
| // Verify that the encoder and decoder has been used |
| TbI420Encoder::FunctionCalls encodeCalls = |
| extEncoder.GetFunctionCalls(); |
| EXPECT_EQ(1, encodeCalls.InitEncode); |
| EXPECT_EQ(1, encodeCalls.Release); |
| EXPECT_EQ(1, encodeCalls.RegisterEncodeCompleteCallback); |
| EXPECT_GT(encodeCalls.Encode, 30); |
| EXPECT_GT(encodeCalls.SetRates, 1); |
| EXPECT_GT(encodeCalls.SetPacketLoss, 1); |
| |
| TbI420Decoder::FunctionCalls decodeCalls = |
| extDecoder.GetFunctionCalls(); |
| EXPECT_EQ(1, decodeCalls.InitDecode); |
| EXPECT_EQ(1, decodeCalls.Release); |
| EXPECT_EQ(1, decodeCalls.RegisterDecodeCompleteCallback); |
| EXPECT_GT(decodeCalls.Decode, 30); |
| |
| ViETest::Log("Changing payload type Using external I420 codec"); |
| |
| codecStruct.plType = codecStruct.plType - 1; |
| EXPECT_EQ(0, ptrViEExtCodec->RegisterExternalReceiveCodec( |
| channel.videoChannel, codecStruct.plType, &extDecoder)); |
| |
| EXPECT_EQ(0, ViE.codec->SetReceiveCodec( |
| channel.videoChannel, codecStruct)); |
| |
| EXPECT_EQ(0, ptrViEExtCodec->RegisterExternalSendCodec( |
| channel.videoChannel, codecStruct.plType, &extEncoder)); |
| |
| // Use new external encoder |
| EXPECT_EQ(0, ViE.codec->SetSendCodec( |
| channel.videoChannel, codecStruct)); |
| |
| AutoTestSleep(KAutoTestSleepTimeMs/2); |
| |
| //*************************************************************** |
| // Testing finished. Tear down Video Engine |
| //*************************************************************** |
| |
| EXPECT_EQ(0, ptrViEExtCodec->DeRegisterExternalSendCodec( |
| channel.videoChannel,codecStruct.plType)); |
| EXPECT_EQ(0, ptrViEExtCodec->DeRegisterExternalReceiveCodec( |
| channel.videoChannel,codecStruct.plType)); |
| |
| // Verify that the encoder and decoder has been used |
| encodeCalls = extEncoder.GetFunctionCalls(); |
| EXPECT_EQ(2, encodeCalls.InitEncode); |
| EXPECT_EQ(2, encodeCalls.Release); |
| EXPECT_EQ(2, encodeCalls.RegisterEncodeCompleteCallback); |
| EXPECT_GT(encodeCalls.Encode, 30); |
| EXPECT_GT(encodeCalls.SetRates, 1); |
| EXPECT_GT(encodeCalls.SetPacketLoss, 1); |
| |
| decodeCalls = extDecoder.GetFunctionCalls(); |
| |
| EXPECT_EQ(2, decodeCalls.InitDecode); |
| EXPECT_EQ(2, decodeCalls.Release); |
| EXPECT_EQ(2, decodeCalls.RegisterDecodeCompleteCallback); |
| EXPECT_GT(decodeCalls.Decode, 30); |
| |
| EXPECT_EQ(0, ptrViEExtCodec->Release()); |
| } // tbI420Encoder and extDecoder goes out of scope |
| |
| ViETest::Log("Using internal I420 codec"); |
| AutoTestSleep(KAutoTestSleepTimeMs/2); |
| |
| } |
| |
| #else |
| ViETest::Log(" ViEExternalCodec not enabled\n"); |
| #endif |
| } |
