Chromium Code Reviews

Unified Diff: webrtc/video/rtp_stream_receiver_unittest.cc

Issue 2641463002: Unit test out of band H264 SPS,PPS within RtpStreamReceiver. (Closed)
Patch Set: Created 3 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments.
Jump to:
View side-by-side diff with in-line comments
« webrtc/video/rtp_stream_receiver.cc ('K') | « webrtc/video/rtp_stream_receiver.cc ('k') | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: webrtc/video/rtp_stream_receiver_unittest.cc
diff --git a/webrtc/video/rtp_stream_receiver_unittest.cc b/webrtc/video/rtp_stream_receiver_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..6e9ab0f91c3059925441b1d121dafe08d2061e02
--- /dev/null
+++ b/webrtc/video/rtp_stream_receiver_unittest.cc
@@ -0,0 +1,214 @@
+/*
+ * Copyright 2016 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 "webrtc/test/gtest.h"
+#include "webrtc/test/gmock.h"
+
+#include "webrtc/base/logging.h"
+#include "webrtc/common_video/h264/h264_common.h"
+#include "webrtc/media/base/mediaconstants.h"
+#include "webrtc/modules/pacing/packet_router.h"
+#include "webrtc/modules/video_coding/include/video_coding_defines.h"
+#include "webrtc/modules/video_coding/frame_object.h"
+#include "webrtc/modules/video_coding/packet.h"
+#include "webrtc/modules/video_coding/rtp_frame_reference_finder.h"
+#include "webrtc/modules/video_coding/timing.h"
+#include "webrtc/modules/utility/include/process_thread.h"
+#include "webrtc/system_wrappers/include/clock.h"
+#include "webrtc/system_wrappers/include/field_trial_default.h"
+#include "webrtc/video/rtp_stream_receiver.h"
+
+namespace webrtc {
+
+namespace {
+
+const char new_jb_enabled[] = "WebRTC-NewVideoJitterBuffer/Enabled/";
sprang_webrtc 2017/01/18 10:05:11 I'd change the name to something like kNewJitterBu
+
+class MockTransport : public Transport {
+ public:
+ MOCK_METHOD3(SendRtp,
+ bool(const uint8_t* packet,
+ size_t length,
+ const PacketOptions& options));
+ MOCK_METHOD2(SendRtcp, bool(const uint8_t* packet, size_t length));
+};
+
+class MockNackSender : public NackSender {
+ public:
+ MOCK_METHOD1(SendNack, void(const std::vector<uint16_t>& sequence_numbers));
+};
+
+class MockKeyFrameRequestSender : public KeyFrameRequestSender {
+ public:
+ MOCK_METHOD0(RequestKeyFrame, void());
+};
+
+class MockOnCompleteFrameCallback
+ : public video_coding::OnCompleteFrameCallback {
+ public:
+ MOCK_METHOD1(DoOnCompleteFrame, void(video_coding::FrameObject* frame));
+ void OnCompleteFrame(std::unique_ptr<video_coding::FrameObject> frame) {
+ DoOnCompleteFrame(frame.get());
+ }
+};
+
+} // namespace
+
+class RtpStreamReceiverTest : public testing::Test {
+ public:
+ RtpStreamReceiverTest()
+ : config_(CreateConfig()),
+ timing_(Clock::GetRealTimeClock()),
+ process_thread_(ProcessThread::Create("TestThread")) {
+ // InitFieldTrials has to done before creation of rtp_stream_receiver_.
sprang_webrtc 2017/01/18 10:05:10 nit: s/has to done/has to be done Or you can move
johan 2017/01/18 12:38:29 Ack
sprang_webrtc 2017/01/23 12:57:09 I don't have super strong preferences, but if the
+ field_trial::InitFieldTrialsFromString(new_jb_enabled);
+ rtp_stream_receiver_.reset(new RtpStreamReceiver(
+ nullptr, nullptr, &mock_transport_, nullptr, nullptr, &packet_router_,
+ nullptr, &config_, nullptr, process_thread_.get(), nullptr,
+ &mock_nack_sender_, &mock_key_frame_request_sender_,
+ &mock_on_complete_frame_callback_, &timing_));
+ }
+
+ WebRtcRTPHeader GetDefaultPacket() {
+ WebRtcRTPHeader packet;
+ memset(&packet, 0, sizeof(packet));
+ packet.type.Video.codec = kRtpVideoH264;
+ return packet;
+ }
+
+ // TODO(Johan): refactor h264_sps_pps_tracker_unittests.cc to avoid duplicate
+ // code.
+ void AddSps(WebRtcRTPHeader* packet, int sps_id, std::vector<uint8_t>* data) {
+ NaluInfo info;
+ info.type = H264::NaluType::kSps;
+ info.sps_id = sps_id;
+ info.pps_id = -1;
+ info.offset = data->size();
+ info.size = 2;
+ data->push_back(H264::NaluType::kSps);
+ data->push_back(sps_id);
+ packet->type.Video.codecHeader.H264
+ .nalus[packet->type.Video.codecHeader.H264.nalus_length++] = info;
+ }
+
+ void AddPps(WebRtcRTPHeader* packet,
+ int sps_id,
+ int pps_id,
+ std::vector<uint8_t>* data) {
+ NaluInfo info;
+ info.type = H264::NaluType::kPps;
+ info.sps_id = sps_id;
+ info.pps_id = pps_id;
+ info.offset = data->size();
+ info.size = 2;
+ data->push_back(H264::NaluType::kPps);
+ data->push_back(pps_id);
+ packet->type.Video.codecHeader.H264
+ .nalus[packet->type.Video.codecHeader.H264.nalus_length++] = info;
+ }
+
+ void AddIdr(WebRtcRTPHeader* packet, int pps_id) {
+ NaluInfo info;
+ info.type = H264::NaluType::kIdr;
+ info.sps_id = -1;
+ info.pps_id = pps_id;
+ packet->type.Video.codecHeader.H264
+ .nalus[packet->type.Video.codecHeader.H264.nalus_length++] = info;
+ }
+
+ protected:
+ static VideoReceiveStream::Config CreateConfig() {
+ VideoReceiveStream::Config config(nullptr);
+ config.rtp.remote_ssrc = 1111;
+ config.rtp.local_ssrc = 2222;
+ return config;
+ }
sprang_webrtc 2017/01/18 10:05:10 nit: \n
+ VideoReceiveStream::Config config_;
+ MockNackSender mock_nack_sender_;
+ MockKeyFrameRequestSender mock_key_frame_request_sender_;
+ MockTransport mock_transport_;
+ MockOnCompleteFrameCallback mock_on_complete_frame_callback_;
+ PacketRouter packet_router_;
+ VCMTiming timing_;
+ std::unique_ptr<ProcessThread> process_thread_;
+ std::unique_ptr<RtpStreamReceiver> rtp_stream_receiver_;
+};
+
+TEST_F(RtpStreamReceiverTest, GenericKeyFrame) {
+ WebRtcRTPHeader rtp_header;
+ const std::vector<uint8_t> data({1, 2, 3, 4});
+ memset(&rtp_header, 0, sizeof(rtp_header));
+ rtp_header.header.sequenceNumber = 1;
+ rtp_header.header.markerBit = 1;
+ rtp_header.type.Video.is_first_packet_in_frame = true;
+ rtp_header.frameType = kVideoFrameKey;
+ rtp_header.type.Video.codec = kRtpVideoGeneric;
+ EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(testing::_));
sprang_webrtc 2017/01/18 10:05:10 add "using ::testing::_;" above
johan 2017/01/18 12:38:30 Acknowledged.
+ rtp_stream_receiver_->OnReceivedPayloadData(data.data(), data.size(),
+ &rtp_header);
+}
+
+TEST_F(RtpStreamReceiverTest, InBandSpsPps) {
+ EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(testing::_));
sprang_webrtc 2017/01/18 10:05:10 When do we expect it? If it's a result of rtp_stre
johan 2017/01/18 12:38:30 OK
+ std::vector<uint8_t> data;
+ WebRtcRTPHeader sps_pps_packet = GetDefaultPacket();
+
+ AddSps(&sps_pps_packet, 0, &data);
+ sps_pps_packet.header.sequenceNumber = 0;
+ rtp_stream_receiver_->OnReceivedPayloadData(data.data(), data.size(),
+ &sps_pps_packet);
+ data.clear();
+ AddPps(&sps_pps_packet, 0, 1, &data);
+ sps_pps_packet.header.sequenceNumber = 1;
+ rtp_stream_receiver_->OnReceivedPayloadData(data.data(), data.size(),
+ &sps_pps_packet);
+ data.clear();
+
+ WebRtcRTPHeader idr_packet = GetDefaultPacket();
+ AddIdr(&idr_packet, 1);
+ idr_packet.type.Video.is_first_packet_in_frame = true;
+ idr_packet.header.sequenceNumber = 2;
+ idr_packet.header.markerBit = 1;
+ idr_packet.type.Video.is_first_packet_in_frame = true;
+ idr_packet.frameType = kVideoFrameKey;
+ idr_packet.type.Video.codec = kRtpVideoH264;
+ data.insert(data.end(), {1, 2, 3});
+ rtp_stream_receiver_->OnReceivedPayloadData(data.data(), data.size(),
+ &idr_packet);
+}
+
+TEST_F(RtpStreamReceiverTest, OutOfBandFmtpSpsPps) {
+ EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(testing::_));
sprang_webrtc 2017/01/18 10:05:10 Same here
+ constexpr int payload_type = 99;
sprang_webrtc 2017/01/18 10:05:11 kPayloadType
+ VideoCodec codec;
+ codec.plType = payload_type;
+ std::map<std::string, std::string> codec_params;
+ // Example parameter sets from https://tools.ietf.org/html/rfc3984#section-8.2
+ // .
+ codec_params.insert(
+ {cricket::kH264FmtpSpropParameterSets, "Z0IACpZTBYmI,aMljiA=="});
+ rtp_stream_receiver_->AddReceiveCodec(codec, codec_params);
+
+ std::vector<uint8_t> data;
+ WebRtcRTPHeader idr_packet = GetDefaultPacket();
+ AddIdr(&idr_packet, 0);
+ idr_packet.header.payloadType = payload_type;
+ idr_packet.type.Video.is_first_packet_in_frame = true;
+ idr_packet.header.sequenceNumber = 2;
+ idr_packet.header.markerBit = 1;
+ idr_packet.type.Video.is_first_packet_in_frame = true;
+ idr_packet.frameType = kVideoFrameKey;
+ idr_packet.type.Video.codec = kRtpVideoH264;
+ data.insert(data.end(), {1, 2, 3});
+ rtp_stream_receiver_->OnReceivedPayloadData(data.data(), data.size(),
+ &idr_packet);
+}
+
+} // namespace webrtc
« webrtc/video/rtp_stream_receiver.cc ('K') | « webrtc/video/rtp_stream_receiver.cc ('k') | no next file » | no next file with comments »

Powered by Google App Engine