ASSERT_TRUE(vda_thread_.Start());
vda_task_runner_ = vda_thread_.message_loop_proxy();
mock_vda_ = new media::MockVideoDecodeAccelerator;
- EXPECT_CALL(*mock_gpu_factories_, GetTaskRunner())
+ EXPECT_CALL(*mock_gpu_factories_.get(), GetTaskRunner())
.WillRepeatedly(Return(vda_task_runner_));
- EXPECT_CALL(*mock_gpu_factories_, DoCreateVideoDecodeAccelerator(_, _))
- .WillRepeatedly(
- Return(static_cast<media::VideoDecodeAccelerator*>(NULL)));
- EXPECT_CALL(*mock_gpu_factories_,
- DoCreateVideoDecodeAccelerator(media::VP8PROFILE_MAIN, _))
+ EXPECT_CALL(*mock_gpu_factories_.get(), DoCreateVideoDecodeAccelerator())
.WillRepeatedly(Return(mock_vda_));
- EXPECT_CALL(*mock_gpu_factories_, CreateSharedMemory(_))
+ EXPECT_CALL(*mock_gpu_factories_.get(), CreateSharedMemory(_))
.WillRepeatedly(Return(static_cast<base::SharedMemory*>(NULL)));
- EXPECT_CALL(*mock_vda_, Destroy());
- rtc_decoder_ =
- RTCVideoDecoder::Create(webrtc::kVideoCodecVP8, mock_gpu_factories_);
+ EXPECT_CALL(*mock_vda_, Initialize(_, _))
+ .Times(1)
+ .WillRepeatedly(Return(true));
+ EXPECT_CALL(*mock_vda_, Destroy()).Times(1);
}
virtual void TearDown() OVERRIDE {
return WEBRTC_VIDEO_CODEC_OK;
}
+ void CreateDecoder(webrtc::VideoCodecType codec_type) {
+ VLOG(2) << "CreateDecoder";
+ codec_.codecType = codec_type;
+ rtc_decoder_ =
+ RTCVideoDecoder::Create(codec_type, mock_gpu_factories_);
+ }
+
void Initialize() {
VLOG(2) << "Initialize";
- codec_.codecType = webrtc::kVideoCodecVP8;
EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, rtc_decoder_->InitDecode(&codec_, 1));
EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
rtc_decoder_->RegisterDecodeCompleteCallback(this));
};
TEST_F(RTCVideoDecoderTest, CreateReturnsNullOnUnsupportedCodec) {
+ CreateDecoder(webrtc::kVideoCodecVP8);
scoped_ptr<RTCVideoDecoder> null_rtc_decoder(
RTCVideoDecoder::Create(webrtc::kVideoCodecI420, mock_gpu_factories_));
EXPECT_EQ(NULL, null_rtc_decoder.get());
}
+TEST_F(RTCVideoDecoderTest, CreateAndInitSucceedsForH264Codec) {
+ CreateDecoder(webrtc::kVideoCodecH264);
+ EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, rtc_decoder_->InitDecode(&codec_, 1));
+}
+
TEST_F(RTCVideoDecoderTest, InitDecodeReturnsErrorOnFeedbackMode) {
- codec_.codecType = webrtc::kVideoCodecVP8;
+ CreateDecoder(webrtc::kVideoCodecVP8);
codec_.codecSpecific.VP8.feedbackModeOn = true;
EXPECT_EQ(WEBRTC_VIDEO_CODEC_ERROR, rtc_decoder_->InitDecode(&codec_, 1));
}
TEST_F(RTCVideoDecoderTest, DecodeReturnsErrorWithoutInitDecode) {
+ CreateDecoder(webrtc::kVideoCodecVP8);
webrtc::EncodedImage input_image;
EXPECT_EQ(WEBRTC_VIDEO_CODEC_UNINITIALIZED,
rtc_decoder_->Decode(input_image, false, NULL, NULL, 0));
}
TEST_F(RTCVideoDecoderTest, DecodeReturnsErrorOnIncompleteFrame) {
+ CreateDecoder(webrtc::kVideoCodecVP8);
Initialize();
webrtc::EncodedImage input_image;
input_image._completeFrame = false;
}
TEST_F(RTCVideoDecoderTest, DecodeReturnsErrorOnMissingFrames) {
+ CreateDecoder(webrtc::kVideoCodecVP8);
Initialize();
webrtc::EncodedImage input_image;
input_image._completeFrame = true;
}
TEST_F(RTCVideoDecoderTest, ResetReturnsOk) {
+ CreateDecoder(webrtc::kVideoCodecVP8);
Initialize();
EXPECT_CALL(*mock_vda_, Reset())
.WillOnce(Invoke(this, &RTCVideoDecoderTest::NotifyResetDone));
}
TEST_F(RTCVideoDecoderTest, ReleaseReturnsOk) {
+ CreateDecoder(webrtc::kVideoCodecVP8);
Initialize();
EXPECT_CALL(*mock_vda_, Reset())
.WillOnce(Invoke(this, &RTCVideoDecoderTest::NotifyResetDone));
}
TEST_F(RTCVideoDecoderTest, InitDecodeAfterRelease) {
+ CreateDecoder(webrtc::kVideoCodecVP8);
EXPECT_CALL(*mock_vda_, Reset())
.WillRepeatedly(Invoke(this, &RTCVideoDecoderTest::NotifyResetDone));
Initialize();
}
TEST_F(RTCVideoDecoderTest, IsBufferAfterReset) {
+ CreateDecoder(webrtc::kVideoCodecVP8);
EXPECT_TRUE(rtc_decoder_->IsBufferAfterReset(0, RTCVideoDecoder::ID_INVALID));
EXPECT_TRUE(rtc_decoder_->IsBufferAfterReset(RTCVideoDecoder::ID_LAST,
RTCVideoDecoder::ID_INVALID));
}
TEST_F(RTCVideoDecoderTest, IsFirstBufferAfterReset) {
+ CreateDecoder(webrtc::kVideoCodecVP8);
EXPECT_TRUE(
rtc_decoder_->IsFirstBufferAfterReset(0, RTCVideoDecoder::ID_INVALID));
EXPECT_FALSE(