content/renderer/media/rtc_video_decoder_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/bind.h"
   6 #include "base/message_loop/message_loop.h"
   7 #include "base/synchronization/waitable_event.h"
   8 #include "base/threading/thread.h"
   9 #include "content/renderer/media/rtc_video_decoder.h"
  10 #include "media/base/gmock_callback_support.h"
  11 #include "media/filters/mock_gpu_video_accelerator_factories.h"
  12 #include "media/video/mock_video_decode_accelerator.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 using ::testing::_;
  16 using ::testing::Invoke;
  17 using ::testing::Return;
  18 using ::testing::SaveArg;
  19 using ::testing::WithArgs;
  20
  21 namespace content {
  22
  23 // TODO(wuchengli): add MockSharedMemroy so more functions can be tested.
  24 class RTCVideoDecoderTest : public ::testing::Test,
  25                             webrtc::DecodedImageCallback {
  26  public:
  27   RTCVideoDecoderTest()
  28       : mock_gpu_factories_(new media::MockGpuVideoAcceleratorFactories),
  29         vda_thread_("vda_thread"),
  30         idle_waiter_(false, false) {
  31     memset(&codec_, 0, sizeof(codec_));
  32   }
  33
  34   virtual void SetUp() OVERRIDE {
  35     ASSERT_TRUE(vda_thread_.Start());
  36     vda_task_runner_ = vda_thread_.message_loop_proxy();
  37     mock_vda_ = new media::MockVideoDecodeAccelerator;
  38     EXPECT_CALL(*mock_gpu_factories_, GetTaskRunner())
  39         .WillRepeatedly(Return(vda_task_runner_));
  40     EXPECT_CALL(*mock_gpu_factories_, DoCreateVideoDecodeAccelerator(_, _))
  41         .WillRepeatedly(
  42              Return(static_cast<media::VideoDecodeAccelerator*>(NULL)));
  43     EXPECT_CALL(*mock_gpu_factories_,
  44                 DoCreateVideoDecodeAccelerator(media::VP8PROFILE_MAIN, _))
  45         .WillRepeatedly(Return(mock_vda_));
  46     EXPECT_CALL(*mock_gpu_factories_, Abort()).WillRepeatedly(Return());
  47     EXPECT_CALL(*mock_gpu_factories_, CreateSharedMemory(_))
  48         .WillRepeatedly(Return(static_cast<base::SharedMemory*>(NULL)));
  49     EXPECT_CALL(*mock_vda_, Destroy());
  50     rtc_decoder_ =
  51         RTCVideoDecoder::Create(webrtc::kVideoCodecVP8, mock_gpu_factories_);
  52   }
  53
  54   virtual void TearDown() OVERRIDE {
  55     VLOG(2) << "TearDown";
  56     if (vda_thread_.IsRunning()) {
  57       RunUntilIdle();  // Wait until all callbascks complete.
  58       vda_task_runner_->DeleteSoon(FROM_HERE, rtc_decoder_.release());
  59       // Make sure the decoder is released before stopping the thread.
  60       RunUntilIdle();
  61       vda_thread_.Stop();
  62     } else {
  63       rtc_decoder_.reset();
  64     }
  65   }
  66
  67   virtual int32_t Decoded(webrtc::I420VideoFrame& decoded_image) OVERRIDE {
  68     VLOG(2) << "Decoded";
  69     EXPECT_EQ(vda_task_runner_, base::MessageLoopProxy::current());
  70     return WEBRTC_VIDEO_CODEC_OK;
  71   }
  72
  73   void Initialize() {
  74     VLOG(2) << "Initialize";
  75     codec_.codecType = webrtc::kVideoCodecVP8;
  76     EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, rtc_decoder_->InitDecode(&codec_, 1));
  77     EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
  78               rtc_decoder_->RegisterDecodeCompleteCallback(this));
  79   }
  80
  81   void NotifyResetDone() {
  82     VLOG(2) << "NotifyResetDone";
  83     vda_task_runner_->PostTask(
  84         FROM_HERE,
  85         base::Bind(&RTCVideoDecoder::NotifyResetDone,
  86                    base::Unretained(rtc_decoder_.get())));
  87   }
  88
  89   void RunUntilIdle() {
  90     VLOG(2) << "RunUntilIdle";
  91     vda_task_runner_->PostTask(FROM_HERE,
  92                                base::Bind(&base::WaitableEvent::Signal,
  93                                           base::Unretained(&idle_waiter_)));
  94     idle_waiter_.Wait();
  95   }
  96
  97  protected:
  98   scoped_refptr<media::MockGpuVideoAcceleratorFactories> mock_gpu_factories_;
  99   media::MockVideoDecodeAccelerator* mock_vda_;
 100   scoped_ptr<RTCVideoDecoder> rtc_decoder_;
 101   webrtc::VideoCodec codec_;
 102   base::Thread vda_thread_;
 103
 104  private:
 105   scoped_refptr<base::SingleThreadTaskRunner> vda_task_runner_;
 106
 107   base::Lock lock_;
 108   base::WaitableEvent idle_waiter_;
 109 };
 110
 111 TEST_F(RTCVideoDecoderTest, CreateReturnsNullOnUnsupportedCodec) {
 112   scoped_ptr<RTCVideoDecoder> null_rtc_decoder(
 113       RTCVideoDecoder::Create(webrtc::kVideoCodecI420, mock_gpu_factories_));
 114   EXPECT_EQ(NULL, null_rtc_decoder.get());
 115 }
 116
 117 TEST_F(RTCVideoDecoderTest, InitDecodeReturnsErrorOnFeedbackMode) {
 118   codec_.codecType = webrtc::kVideoCodecVP8;
 119   codec_.codecSpecific.VP8.feedbackModeOn = true;
 120   EXPECT_EQ(WEBRTC_VIDEO_CODEC_ERROR, rtc_decoder_->InitDecode(&codec_, 1));
 121 }
 122
 123 TEST_F(RTCVideoDecoderTest, DecodeReturnsErrorWithoutInitDecode) {
 124   webrtc::EncodedImage input_image;
 125   EXPECT_EQ(WEBRTC_VIDEO_CODEC_UNINITIALIZED,
 126             rtc_decoder_->Decode(input_image, false, NULL, NULL, 0));
 127 }
 128
 129 TEST_F(RTCVideoDecoderTest, DecodeReturnsErrorOnIncompleteFrame) {
 130   Initialize();
 131   webrtc::EncodedImage input_image;
 132   input_image._completeFrame = false;
 133   EXPECT_EQ(WEBRTC_VIDEO_CODEC_ERROR,
 134             rtc_decoder_->Decode(input_image, false, NULL, NULL, 0));
 135 }
 136
 137 TEST_F(RTCVideoDecoderTest, DecodeReturnsErrorOnMissingFrames) {
 138   Initialize();
 139   webrtc::EncodedImage input_image;
 140   input_image._completeFrame = true;
 141   bool missingFrames = true;
 142   EXPECT_EQ(WEBRTC_VIDEO_CODEC_ERROR,
 143             rtc_decoder_->Decode(input_image, missingFrames, NULL, NULL, 0));
 144 }
 145
 146 TEST_F(RTCVideoDecoderTest, ResetReturnsOk) {
 147   Initialize();
 148   EXPECT_CALL(*mock_vda_, Reset())
 149       .WillOnce(Invoke(this, &RTCVideoDecoderTest::NotifyResetDone));
 150   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, rtc_decoder_->Reset());
 151 }
 152
 153 TEST_F(RTCVideoDecoderTest, ReleaseReturnsOk) {
 154   Initialize();
 155   EXPECT_CALL(*mock_vda_, Reset())
 156       .WillOnce(Invoke(this, &RTCVideoDecoderTest::NotifyResetDone));
 157   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, rtc_decoder_->Release());
 158 }
 159
 160 TEST_F(RTCVideoDecoderTest, InitDecodeAfterRelease) {
 161   EXPECT_CALL(*mock_vda_, Reset())
 162       .WillRepeatedly(Invoke(this, &RTCVideoDecoderTest::NotifyResetDone));
 163   Initialize();
 164   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, rtc_decoder_->Release());
 165   Initialize();
 166   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, rtc_decoder_->Release());
 167 }
 168
 169 TEST_F(RTCVideoDecoderTest, VdaThreadStops) { vda_thread_.Stop(); }
 170
 171 TEST_F(RTCVideoDecoderTest, IsBufferAfterReset) {
 172   EXPECT_TRUE(rtc_decoder_->IsBufferAfterReset(0, RTCVideoDecoder::ID_INVALID));
 173   EXPECT_TRUE(rtc_decoder_->IsBufferAfterReset(RTCVideoDecoder::ID_LAST,
 174                                                RTCVideoDecoder::ID_INVALID));
 175   EXPECT_FALSE(rtc_decoder_->IsBufferAfterReset(RTCVideoDecoder::ID_HALF - 2,
 176                                                 RTCVideoDecoder::ID_HALF + 2));
 177   EXPECT_TRUE(rtc_decoder_->IsBufferAfterReset(RTCVideoDecoder::ID_HALF + 2,
 178                                                RTCVideoDecoder::ID_HALF - 2));
 179
 180   EXPECT_FALSE(rtc_decoder_->IsBufferAfterReset(0, 0));
 181   EXPECT_TRUE(rtc_decoder_->IsBufferAfterReset(0, RTCVideoDecoder::ID_LAST));
 182   EXPECT_FALSE(
 183       rtc_decoder_->IsBufferAfterReset(0, RTCVideoDecoder::ID_HALF - 2));
 184   EXPECT_TRUE(
 185       rtc_decoder_->IsBufferAfterReset(0, RTCVideoDecoder::ID_HALF + 2));
 186
 187   EXPECT_FALSE(rtc_decoder_->IsBufferAfterReset(RTCVideoDecoder::ID_LAST, 0));
 188   EXPECT_FALSE(rtc_decoder_->IsBufferAfterReset(RTCVideoDecoder::ID_LAST,
 189                                                 RTCVideoDecoder::ID_HALF - 2));
 190   EXPECT_TRUE(rtc_decoder_->IsBufferAfterReset(RTCVideoDecoder::ID_LAST,
 191                                                RTCVideoDecoder::ID_HALF + 2));
 192   EXPECT_FALSE(rtc_decoder_->IsBufferAfterReset(RTCVideoDecoder::ID_LAST,
 193                                                 RTCVideoDecoder::ID_LAST));
 194 }
 195
 196 TEST_F(RTCVideoDecoderTest, IsFirstBufferAfterReset) {
 197   EXPECT_TRUE(
 198       rtc_decoder_->IsFirstBufferAfterReset(0, RTCVideoDecoder::ID_INVALID));
 199   EXPECT_FALSE(
 200       rtc_decoder_->IsFirstBufferAfterReset(1, RTCVideoDecoder::ID_INVALID));
 201   EXPECT_FALSE(rtc_decoder_->IsFirstBufferAfterReset(0, 0));
 202   EXPECT_TRUE(rtc_decoder_->IsFirstBufferAfterReset(1, 0));
 203   EXPECT_FALSE(rtc_decoder_->IsFirstBufferAfterReset(2, 0));
 204
 205   EXPECT_FALSE(rtc_decoder_->IsFirstBufferAfterReset(RTCVideoDecoder::ID_HALF,
 206                                                      RTCVideoDecoder::ID_HALF));
 207   EXPECT_TRUE(rtc_decoder_->IsFirstBufferAfterReset(
 208       RTCVideoDecoder::ID_HALF + 1, RTCVideoDecoder::ID_HALF));
 209   EXPECT_FALSE(rtc_decoder_->IsFirstBufferAfterReset(
 210       RTCVideoDecoder::ID_HALF + 2, RTCVideoDecoder::ID_HALF));
 211
 212   EXPECT_FALSE(rtc_decoder_->IsFirstBufferAfterReset(RTCVideoDecoder::ID_LAST,
 213                                                      RTCVideoDecoder::ID_LAST));
 214   EXPECT_TRUE(
 215       rtc_decoder_->IsFirstBufferAfterReset(0, RTCVideoDecoder::ID_LAST));
 216   EXPECT_FALSE(
 217       rtc_decoder_->IsFirstBufferAfterReset(1, RTCVideoDecoder::ID_LAST));
 218 }
 219
 220 }  // content