#include "media/cast/net/cast_transport_config.h"
#include "media/cast/net/cast_transport_sender_impl.h"
#include "media/cast/net/pacing/paced_sender.h"
-#include "media/cast/net/rtcp/rtcp_receiver.h"
#include "media/cast/sender/video_sender.h"
#include "media/cast/test/fake_single_thread_task_runner.h"
#include "media/cast/test/fake_video_encode_accelerator.h"
callback.Run(shm.Pass());
}
+void SaveInitializationStatus(CastInitializationStatus* out_status,
+ CastInitializationStatus in_status) {
+ *out_status = in_status;
+}
+
class TestPacketSender : public PacketSender {
public:
TestPacketSender()
callback_ = cb;
return false;
}
- if (RtcpReceiver::IsRtcpPacket(&packet->data[0], packet->data.size())) {
+ if (Rtcp::IsRtcpPacket(&packet->data[0], packet->data.size())) {
++number_of_rtcp_packets_;
} else {
// Check that at least one RTCP packet was sent before the first RTP
return true;
}
+ virtual int64 GetBytesSent() OVERRIDE {
+ return 0;
+ }
+
int number_of_rtp_packets() const { return number_of_rtp_packets_; }
int number_of_rtcp_packets() const { return number_of_rtcp_packets_; }
void SetPause(bool paused) {
paused_ = paused;
- if (!paused && stored_packet_) {
+ if (!paused && stored_packet_.get()) {
SendPacket(stored_packet_, callback_);
callback_.Run();
}
DISALLOW_COPY_AND_ASSIGN(TestPacketSender);
};
+void IgnorePlayoutDelayChanges(base::TimeDelta unused_playout_delay) {
+}
class PeerVideoSender : public VideoSender {
public:
PeerVideoSender(
scoped_refptr<CastEnvironment> cast_environment,
const VideoSenderConfig& video_config,
+ const CastInitializationCallback& initialization_cb,
const CreateVideoEncodeAcceleratorCallback& create_vea_cb,
const CreateVideoEncodeMemoryCallback& create_video_encode_mem_cb,
CastTransportSender* const transport_sender)
: VideoSender(cast_environment,
video_config,
+ initialization_cb,
create_vea_cb,
create_video_encode_mem_cb,
- transport_sender) {}
+ transport_sender,
+ base::Bind(&IgnorePlayoutDelayChanges)) {}
using VideoSender::OnReceivedCastFeedback;
};
} // namespace
NULL,
testing_clock_,
dummy_endpoint,
+ make_scoped_ptr(new base::DictionaryValue),
base::Bind(&UpdateCastTransportStatus),
BulkRawEventsCallback(),
base::TimeDelta(),
EXPECT_EQ(TRANSPORT_VIDEO_INITIALIZED, status);
}
- void InitEncoder(bool external) {
+ // If |external| is true then external video encoder (VEA) is used.
+ // |expect_init_sucess| is true if initialization is expected to succeed.
+ CastInitializationStatus InitEncoder(bool external,
+ bool expect_init_success) {
VideoSenderConfig video_config;
video_config.ssrc = 1;
video_config.incoming_feedback_ssrc = 2;
video_config.max_frame_rate = 30;
video_config.max_number_of_video_buffers_used = 1;
video_config.codec = CODEC_VIDEO_VP8;
+ CastInitializationStatus status = STATUS_VIDEO_UNINITIALIZED;
if (external) {
- scoped_ptr<VideoEncodeAccelerator> fake_vea(
- new test::FakeVideoEncodeAccelerator(task_runner_,
- &stored_bitrates_));
+ test::FakeVideoEncodeAccelerator* fake_vea =
+ new test::FakeVideoEncodeAccelerator(
+ task_runner_, &stored_bitrates_);
+ fake_vea->SetWillInitializationSucceed(expect_init_success);
+ scoped_ptr<VideoEncodeAccelerator> fake_vea_owner(fake_vea);
video_sender_.reset(
new PeerVideoSender(cast_environment_,
video_config,
+ base::Bind(&SaveInitializationStatus,
+ &status),
base::Bind(&CreateVideoEncodeAccelerator,
task_runner_,
- base::Passed(&fake_vea)),
+ base::Passed(&fake_vea_owner)),
base::Bind(&CreateSharedMemory),
transport_sender_.get()));
} else {
video_sender_.reset(
new PeerVideoSender(cast_environment_,
video_config,
+ base::Bind(&SaveInitializationStatus,
+ &status),
CreateDefaultVideoEncodeAcceleratorCallback(),
CreateDefaultVideoEncodeMemoryCallback(),
transport_sender_.get()));
}
- ASSERT_EQ(STATUS_VIDEO_INITIALIZED, video_sender_->InitializationResult());
+ task_runner_->RunTasks();
+ return status;
}
scoped_refptr<media::VideoFrame> GetNewVideoFrame() {
scoped_refptr<media::VideoFrame> video_frame =
media::VideoFrame::CreateFrame(
VideoFrame::I420, size, gfx::Rect(size), size, base::TimeDelta());
- PopulateVideoFrame(video_frame, last_pixel_value_++);
+ PopulateVideoFrame(video_frame.get(), last_pixel_value_++);
return video_frame;
}
scoped_refptr<media::VideoFrame> video_frame =
media::VideoFrame::CreateFrame(
VideoFrame::I420, size, gfx::Rect(size), size, base::TimeDelta());
- PopulateVideoFrameWithNoise(video_frame);
+ PopulateVideoFrameWithNoise(video_frame.get());
return video_frame;
}
};
TEST_F(VideoSenderTest, BuiltInEncoder) {
- InitEncoder(false);
+ EXPECT_EQ(STATUS_VIDEO_INITIALIZED, InitEncoder(false, true));
scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
const base::TimeTicks capture_time = testing_clock_->NowTicks();
}
TEST_F(VideoSenderTest, ExternalEncoder) {
- InitEncoder(true);
- task_runner_->RunTasks();
+ EXPECT_EQ(STATUS_VIDEO_INITIALIZED, InitEncoder(true, true));
scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
// Fixed bitrate is used for external encoder. Bitrate is only once
// to the encoder.
EXPECT_EQ(1u, stored_bitrates_.size());
+ video_sender_.reset(NULL);
+ task_runner_->RunTasks();
+}
- // We need to run the task to cleanup the GPU instance.
+TEST_F(VideoSenderTest, ExternalEncoderInitFails) {
+ EXPECT_EQ(STATUS_HW_VIDEO_ENCODER_NOT_SUPPORTED,
+ InitEncoder(true, false));
video_sender_.reset(NULL);
task_runner_->RunTasks();
}
TEST_F(VideoSenderTest, RtcpTimer) {
- InitEncoder(false);
+ EXPECT_EQ(STATUS_VIDEO_INITIALIZED, InitEncoder(false, true));
scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
}
TEST_F(VideoSenderTest, ResendTimer) {
- InitEncoder(false);
+ EXPECT_EQ(STATUS_VIDEO_INITIALIZED, InitEncoder(false, true));
scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
}
TEST_F(VideoSenderTest, LogAckReceivedEvent) {
- InitEncoder(false);
+ EXPECT_EQ(STATUS_VIDEO_INITIALIZED, InitEncoder(false, true));
SimpleEventSubscriber event_subscriber;
cast_environment_->Logging()->AddRawEventSubscriber(&event_subscriber);
}
TEST_F(VideoSenderTest, StopSendingInTheAbsenceOfAck) {
- InitEncoder(false);
+ EXPECT_EQ(STATUS_VIDEO_INITIALIZED, InitEncoder(false, true));
// Send a stream of frames and don't ACK; by default we shouldn't have more
// than 4 frames in flight.
scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
}
TEST_F(VideoSenderTest, DuplicateAckRetransmit) {
- InitEncoder(false);
+ EXPECT_EQ(STATUS_VIDEO_INITIALIZED, InitEncoder(false, true));
scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
video_sender_->InsertRawVideoFrame(video_frame, testing_clock_->NowTicks());
RunTasks(33);
}
TEST_F(VideoSenderTest, DuplicateAckRetransmitDoesNotCancelRetransmits) {
- InitEncoder(false);
+ EXPECT_EQ(STATUS_VIDEO_INITIALIZED, InitEncoder(false, true));
scoped_refptr<media::VideoFrame> video_frame = GetNewVideoFrame();
video_sender_->InsertRawVideoFrame(video_frame, testing_clock_->NowTicks());
RunTasks(33);
}
TEST_F(VideoSenderTest, AcksCancelRetransmits) {
- InitEncoder(false);
+ EXPECT_EQ(STATUS_VIDEO_INITIALIZED, InitEncoder(false, true));
transport_.SetPause(true);
scoped_refptr<media::VideoFrame> video_frame = GetLargeNewVideoFrame();
video_sender_->InsertRawVideoFrame(video_frame, testing_clock_->NowTicks());
EXPECT_EQ(0, transport_.number_of_rtp_packets());
}
-TEST_F(VideoSenderTest, NAcksCancelRetransmits) {
- InitEncoder(false);
- transport_.SetPause(true);
- // Send two video frames.
- scoped_refptr<media::VideoFrame> video_frame = GetLargeNewVideoFrame();
- video_sender_->InsertRawVideoFrame(video_frame, testing_clock_->NowTicks());
- RunTasks(33);
- video_frame = GetLargeNewVideoFrame();
- video_sender_->InsertRawVideoFrame(video_frame, testing_clock_->NowTicks());
- RunTasks(33);
-
- // Frames should be in buffer, waiting. Now let's ack the first one and nack
- // one packet in the second one.
- RtcpCastMessage cast_feedback(1);
- cast_feedback.media_ssrc = 2;
- cast_feedback.ack_frame_id = 0;
- PacketIdSet missing_packets;
- missing_packets.insert(0);
- cast_feedback.missing_frames_and_packets[1] = missing_packets;
- video_sender_->OnReceivedCastFeedback(cast_feedback);
-
- transport_.SetPause(false);
- RunTasks(33);
- // Only one packet should be retransmitted.
- EXPECT_EQ(1, transport_.number_of_rtp_packets());
-}
-
} // namespace cast
} // namespace media
projects / platform / framework / web / crosswalk.git / blobdiff