src/media/filters/video_frame_stream_unittest.cc

   1 // Copyright (c) 2012 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/callback_helpers.h"
   7 #include "base/message_loop/message_loop.h"
   8 #include "media/base/gmock_callback_support.h"
   9 #include "media/base/mock_filters.h"
  10 #include "media/base/test_helpers.h"
  11 #include "media/filters/fake_demuxer_stream.h"
  12 #include "media/filters/fake_video_decoder.h"
  13 #include "media/filters/video_frame_stream.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15
  16 using ::testing::_;
  17 using ::testing::Assign;
  18 using ::testing::Invoke;
  19 using ::testing::NiceMock;
  20 using ::testing::Return;
  21 using ::testing::SaveArg;
  22
  23 static const int kNumConfigs = 3;
  24 static const int kNumBuffersInOneConfig = 5;
  25 static const int kDecodingDelay = 7;
  26
  27 namespace media {
  28
  29 class VideoFrameStreamTest : public testing::TestWithParam<bool> {
  30  public:
  31   VideoFrameStreamTest()
  32       : demuxer_stream_(new FakeDemuxerStream(kNumConfigs,
  33                                               kNumBuffersInOneConfig,
  34                                               GetParam())),
  35         decryptor_(new NiceMock<MockDecryptor>()),
  36         decoder_(new FakeVideoDecoder(kDecodingDelay)),
  37         is_initialized_(false),
  38         num_decoded_frames_(0),
  39         pending_initialize_(false),
  40         pending_read_(false),
  41         pending_reset_(false),
  42         pending_stop_(false),
  43         total_bytes_decoded_(0),
  44         has_no_key_(false) {
  45     ScopedVector<VideoDecoder> decoders;
  46     decoders.push_back(decoder_);
  47
  48     video_frame_stream_.reset(new VideoFrameStream(
  49         message_loop_.message_loop_proxy(),
  50         decoders.Pass(),
  51         base::Bind(&VideoFrameStreamTest::SetDecryptorReadyCallback,
  52                    base::Unretained(this))));
  53
  54     // Decryptor can only decrypt (not decrypt-and-decode) so that
  55     // DecryptingDemuxerStream will be used.
  56     EXPECT_CALL(*decryptor_, InitializeVideoDecoder(_, _))
  57         .WillRepeatedly(RunCallback<1>(false));
  58     EXPECT_CALL(*decryptor_, Decrypt(_, _, _))
  59         .WillRepeatedly(Invoke(this, &VideoFrameStreamTest::Decrypt));
  60   }
  61
  62   ~VideoFrameStreamTest() {
  63     DCHECK(!pending_initialize_);
  64     DCHECK(!pending_read_);
  65     DCHECK(!pending_reset_);
  66     DCHECK(!pending_stop_);
  67
  68     if (is_initialized_)
  69       Stop();
  70     EXPECT_FALSE(is_initialized_);
  71   }
  72
  73   MOCK_METHOD1(SetDecryptorReadyCallback, void(const media::DecryptorReadyCB&));
  74
  75   void OnStatistics(const PipelineStatistics& statistics) {
  76     total_bytes_decoded_ += statistics.video_bytes_decoded;
  77   }
  78
  79   void OnInitialized(bool success, bool has_alpha) {
  80     DCHECK(!pending_read_);
  81     DCHECK(!pending_reset_);
  82     DCHECK(pending_initialize_);
  83     pending_initialize_ = false;
  84
  85     is_initialized_ = success;
  86     if (!success)
  87       decoder_ = NULL;
  88   }
  89
  90   void InitializeVideoFrameStream() {
  91     pending_initialize_ = true;
  92     video_frame_stream_->Initialize(
  93         demuxer_stream_.get(),
  94         base::Bind(&VideoFrameStreamTest::OnStatistics, base::Unretained(this)),
  95         base::Bind(&VideoFrameStreamTest::OnInitialized,
  96                    base::Unretained(this)));
  97     message_loop_.RunUntilIdle();
  98   }
  99
 100   // Fake Decrypt() function used by DecryptingDemuxerStream. It does nothing
 101   // but removes the DecryptConfig to make the buffer unencrypted.
 102   void Decrypt(Decryptor::StreamType stream_type,
 103                const scoped_refptr<DecoderBuffer>& encrypted,
 104                const Decryptor::DecryptCB& decrypt_cb) {
 105     if (has_no_key_) {
 106       decrypt_cb.Run(Decryptor::kNoKey, NULL);
 107       return;
 108     }
 109
 110     DCHECK_EQ(stream_type, Decryptor::kVideo);
 111     scoped_refptr<DecoderBuffer> decrypted = DecoderBuffer::CopyFrom(
 112         encrypted->data(), encrypted->data_size());
 113     decrypted->set_timestamp(encrypted->timestamp());
 114     decrypted->set_duration(encrypted->duration());
 115     decrypt_cb.Run(Decryptor::kSuccess, decrypted);
 116   }
 117
 118   // Callback for VideoFrameStream::Read().
 119   void FrameReady(VideoFrameStream::Status status,
 120                   const scoped_refptr<VideoFrame>& frame) {
 121     DCHECK(pending_read_);
 122     // TODO(xhwang): Add test cases where the fake decoder returns error or
 123     // the fake demuxer aborts demuxer read.
 124     ASSERT_TRUE(status == VideoFrameStream::OK ||
 125                 status == VideoFrameStream::ABORTED) << status;
 126     frame_read_ = frame;
 127     if (frame.get() && !frame->IsEndOfStream())
 128       num_decoded_frames_++;
 129     pending_read_ = false;
 130   }
 131
 132   void OnReset() {
 133     DCHECK(!pending_read_);
 134     DCHECK(pending_reset_);
 135     pending_reset_ = false;
 136   }
 137
 138   void OnStopped() {
 139     DCHECK(!pending_read_);
 140     DCHECK(!pending_reset_);
 141     DCHECK(pending_stop_);
 142     pending_stop_ = false;
 143     is_initialized_ = false;
 144     decoder_ = NULL;
 145   }
 146
 147   void ReadOneFrame() {
 148     frame_read_ = NULL;
 149     pending_read_ = true;
 150     video_frame_stream_->Read(base::Bind(
 151         &VideoFrameStreamTest::FrameReady, base::Unretained(this)));
 152     message_loop_.RunUntilIdle();
 153   }
 154
 155   void ReadUntilPending() {
 156     do {
 157       ReadOneFrame();
 158     } while (!pending_read_);
 159   }
 160
 161   enum PendingState {
 162     NOT_PENDING,
 163     DEMUXER_READ_NORMAL,
 164     DEMUXER_READ_CONFIG_CHANGE,
 165     SET_DECRYPTOR,
 166     DECRYPTOR_NO_KEY,
 167     DECODER_INIT,
 168     DECODER_REINIT,
 169     DECODER_READ,
 170     DECODER_RESET,
 171     DECODER_STOP
 172   };
 173
 174   void EnterPendingState(PendingState state) {
 175     DCHECK_NE(state, NOT_PENDING);
 176     switch (state) {
 177       case DEMUXER_READ_NORMAL:
 178         demuxer_stream_->HoldNextRead();
 179         ReadUntilPending();
 180         break;
 181
 182       case DEMUXER_READ_CONFIG_CHANGE:
 183         demuxer_stream_->HoldNextConfigChangeRead();
 184         ReadUntilPending();
 185         break;
 186
 187       case SET_DECRYPTOR:
 188         // Hold DecryptorReadyCB.
 189         EXPECT_CALL(*this, SetDecryptorReadyCallback(_))
 190             .Times(2);
 191         // Initialize will fail because no decryptor is available.
 192         InitializeVideoFrameStream();
 193         break;
 194
 195       case DECRYPTOR_NO_KEY:
 196         EXPECT_CALL(*this, SetDecryptorReadyCallback(_))
 197             .WillRepeatedly(RunCallback<0>(decryptor_.get()));
 198         has_no_key_ = true;
 199         ReadOneFrame();
 200         break;
 201
 202       case DECODER_INIT:
 203         EXPECT_CALL(*this, SetDecryptorReadyCallback(_))
 204             .WillRepeatedly(RunCallback<0>(decryptor_.get()));
 205         decoder_->HoldNextInit();
 206         InitializeVideoFrameStream();
 207         break;
 208
 209       case DECODER_REINIT:
 210         decoder_->HoldNextInit();
 211         ReadUntilPending();
 212         break;
 213
 214       case DECODER_READ:
 215         decoder_->HoldNextRead();
 216         ReadUntilPending();
 217         break;
 218
 219       case DECODER_RESET:
 220         decoder_->HoldNextReset();
 221         pending_reset_ = true;
 222         video_frame_stream_->Reset(base::Bind(&VideoFrameStreamTest::OnReset,
 223                                               base::Unretained(this)));
 224         message_loop_.RunUntilIdle();
 225         break;
 226
 227       case DECODER_STOP:
 228         decoder_->HoldNextStop();
 229         // Check that the pipeline statistics callback was fired correctly.
 230         EXPECT_EQ(decoder_->total_bytes_decoded(), total_bytes_decoded_);
 231         pending_stop_ = true;
 232         video_frame_stream_->Stop(base::Bind(&VideoFrameStreamTest::OnStopped,
 233                                              base::Unretained(this)));
 234         message_loop_.RunUntilIdle();
 235         break;
 236
 237       case NOT_PENDING:
 238         NOTREACHED();
 239         break;
 240     }
 241   }
 242
 243   void SatisfyPendingCallback(PendingState state) {
 244     DCHECK_NE(state, NOT_PENDING);
 245     switch (state) {
 246       case DEMUXER_READ_NORMAL:
 247       case DEMUXER_READ_CONFIG_CHANGE:
 248         demuxer_stream_->SatisfyRead();
 249         break;
 250
 251       // These two cases are only interesting to test during
 252       // VideoFrameStream::Stop().  There's no need to satisfy a callback.
 253       case SET_DECRYPTOR:
 254       case DECRYPTOR_NO_KEY:
 255         NOTREACHED();
 256         break;
 257
 258       case DECODER_INIT:
 259         decoder_->SatisfyInit();
 260         break;
 261
 262       case DECODER_REINIT:
 263         decoder_->SatisfyInit();
 264         break;
 265
 266       case DECODER_READ:
 267         decoder_->SatisfyRead();
 268         break;
 269
 270       case DECODER_RESET:
 271         decoder_->SatisfyReset();
 272         break;
 273
 274       case DECODER_STOP:
 275         DCHECK(pending_stop_);
 276         decoder_->SatisfyStop();
 277         break;
 278
 279       case NOT_PENDING:
 280         NOTREACHED();
 281         break;
 282     }
 283
 284     message_loop_.RunUntilIdle();
 285   }
 286
 287   void Initialize() {
 288     EnterPendingState(DECODER_INIT);
 289     SatisfyPendingCallback(DECODER_INIT);
 290   }
 291
 292   void Read() {
 293     EnterPendingState(DECODER_READ);
 294     SatisfyPendingCallback(DECODER_READ);
 295   }
 296
 297   void Reset() {
 298     EnterPendingState(DECODER_RESET);
 299     SatisfyPendingCallback(DECODER_RESET);
 300   }
 301
 302   void Stop() {
 303     EnterPendingState(DECODER_STOP);
 304     SatisfyPendingCallback(DECODER_STOP);
 305   }
 306
 307   base::MessageLoop message_loop_;
 308
 309   scoped_ptr<VideoFrameStream> video_frame_stream_;
 310   scoped_ptr<FakeDemuxerStream> demuxer_stream_;
 311   // Use NiceMock since we don't care about most of calls on the decryptor,
 312   // e.g. RegisterNewKeyCB().
 313   scoped_ptr<NiceMock<MockDecryptor> > decryptor_;
 314   FakeVideoDecoder* decoder_;  // Owned by |video_frame_stream_|.
 315
 316   bool is_initialized_;
 317   int num_decoded_frames_;
 318   bool pending_initialize_;
 319   bool pending_read_;
 320   bool pending_reset_;
 321   bool pending_stop_;
 322   int total_bytes_decoded_;
 323   scoped_refptr<VideoFrame> frame_read_;
 324
 325   // Decryptor has no key to decrypt a frame.
 326   bool has_no_key_;
 327
 328  private:
 329   DISALLOW_COPY_AND_ASSIGN(VideoFrameStreamTest);
 330 };
 331
 332 INSTANTIATE_TEST_CASE_P(Clear, VideoFrameStreamTest, testing::Values(false));
 333 INSTANTIATE_TEST_CASE_P(Encrypted, VideoFrameStreamTest, testing::Values(true));
 334
 335 TEST_P(VideoFrameStreamTest, Initialization) {
 336   Initialize();
 337 }
 338
 339 TEST_P(VideoFrameStreamTest, ReadOneFrame) {
 340   Initialize();
 341   Read();
 342 }
 343
 344 TEST_P(VideoFrameStreamTest, ReadAllFrames) {
 345   Initialize();
 346   do {
 347     Read();
 348   } while (frame_read_.get() && !frame_read_->IsEndOfStream());
 349
 350   const int total_num_frames = kNumConfigs * kNumBuffersInOneConfig;
 351   DCHECK_EQ(num_decoded_frames_, total_num_frames);
 352 }
 353
 354 TEST_P(VideoFrameStreamTest, Read_AfterReset) {
 355   Initialize();
 356   Reset();
 357   Read();
 358   Reset();
 359   Read();
 360 }
 361
 362 // No Reset() before initialization is successfully completed.
 363
 364 TEST_P(VideoFrameStreamTest, Reset_AfterInitialization) {
 365   Initialize();
 366   Reset();
 367   Read();
 368 }
 369
 370 TEST_P(VideoFrameStreamTest, Reset_DuringReinitialization) {
 371   Initialize();
 372   EnterPendingState(DECODER_REINIT);
 373   // VideoDecoder::Reset() is not called when we reset during reinitialization.
 374   pending_reset_ = true;
 375   video_frame_stream_->Reset(
 376       base::Bind(&VideoFrameStreamTest::OnReset, base::Unretained(this)));
 377   SatisfyPendingCallback(DECODER_REINIT);
 378   Read();
 379 }
 380
 381 TEST_P(VideoFrameStreamTest, Reset_AfterReinitialization) {
 382   Initialize();
 383   EnterPendingState(DECODER_REINIT);
 384   SatisfyPendingCallback(DECODER_REINIT);
 385   Reset();
 386   Read();
 387 }
 388
 389 TEST_P(VideoFrameStreamTest, Reset_DuringDemuxerRead_Normal) {
 390   Initialize();
 391   EnterPendingState(DEMUXER_READ_NORMAL);
 392   EnterPendingState(DECODER_RESET);
 393   SatisfyPendingCallback(DEMUXER_READ_NORMAL);
 394   SatisfyPendingCallback(DECODER_RESET);
 395   Read();
 396 }
 397
 398 TEST_P(VideoFrameStreamTest, Reset_DuringDemuxerRead_ConfigChange) {
 399   Initialize();
 400   EnterPendingState(DEMUXER_READ_CONFIG_CHANGE);
 401   EnterPendingState(DECODER_RESET);
 402   SatisfyPendingCallback(DEMUXER_READ_CONFIG_CHANGE);
 403   SatisfyPendingCallback(DECODER_RESET);
 404   Read();
 405 }
 406
 407 TEST_P(VideoFrameStreamTest, Reset_DuringNormalDecoderRead) {
 408   Initialize();
 409   EnterPendingState(DECODER_READ);
 410   EnterPendingState(DECODER_RESET);
 411   SatisfyPendingCallback(DECODER_READ);
 412   SatisfyPendingCallback(DECODER_RESET);
 413   Read();
 414 }
 415
 416 TEST_P(VideoFrameStreamTest, Reset_AfterNormalRead) {
 417   Initialize();
 418   Read();
 419   Reset();
 420   Read();
 421 }
 422
 423 TEST_P(VideoFrameStreamTest, Reset_AfterDemuxerRead_ConfigChange) {
 424   Initialize();
 425   EnterPendingState(DEMUXER_READ_CONFIG_CHANGE);
 426   SatisfyPendingCallback(DEMUXER_READ_CONFIG_CHANGE);
 427   Reset();
 428   Read();
 429 }
 430
 431 TEST_P(VideoFrameStreamTest, Reset_DuringNoKeyRead) {
 432   Initialize();
 433   EnterPendingState(DECRYPTOR_NO_KEY);
 434   Reset();
 435 }
 436
 437 TEST_P(VideoFrameStreamTest, Stop_BeforeInitialization) {
 438   pending_stop_ = true;
 439   video_frame_stream_->Stop(
 440       base::Bind(&VideoFrameStreamTest::OnStopped, base::Unretained(this)));
 441   message_loop_.RunUntilIdle();
 442 }
 443
 444 TEST_P(VideoFrameStreamTest, Stop_DuringSetDecryptor) {
 445   if (!GetParam()) {
 446     DVLOG(1) << "SetDecryptor test only runs when the stream is encrytped.";
 447     return;
 448   }
 449
 450   EnterPendingState(SET_DECRYPTOR);
 451   pending_stop_ = true;
 452   video_frame_stream_->Stop(
 453       base::Bind(&VideoFrameStreamTest::OnStopped, base::Unretained(this)));
 454   message_loop_.RunUntilIdle();
 455 }
 456
 457 TEST_P(VideoFrameStreamTest, Stop_DuringInitialization) {
 458   EnterPendingState(DECODER_INIT);
 459   EnterPendingState(DECODER_STOP);
 460   SatisfyPendingCallback(DECODER_INIT);
 461   SatisfyPendingCallback(DECODER_STOP);
 462 }
 463
 464 TEST_P(VideoFrameStreamTest, Stop_AfterInitialization) {
 465   Initialize();
 466   Stop();
 467 }
 468
 469 TEST_P(VideoFrameStreamTest, Stop_DuringReinitialization) {
 470   Initialize();
 471   EnterPendingState(DECODER_REINIT);
 472   EnterPendingState(DECODER_STOP);
 473   SatisfyPendingCallback(DECODER_REINIT);
 474   SatisfyPendingCallback(DECODER_STOP);
 475 }
 476
 477 TEST_P(VideoFrameStreamTest, Stop_AfterReinitialization) {
 478   Initialize();
 479   EnterPendingState(DECODER_REINIT);
 480   SatisfyPendingCallback(DECODER_REINIT);
 481   Stop();
 482 }
 483
 484 TEST_P(VideoFrameStreamTest, Stop_DuringDemuxerRead_Normal) {
 485   Initialize();
 486   EnterPendingState(DEMUXER_READ_NORMAL);
 487   EnterPendingState(DECODER_STOP);
 488   SatisfyPendingCallback(DEMUXER_READ_NORMAL);
 489   SatisfyPendingCallback(DECODER_STOP);
 490 }
 491
 492 TEST_P(VideoFrameStreamTest, Stop_DuringDemuxerRead_ConfigChange) {
 493   Initialize();
 494   EnterPendingState(DEMUXER_READ_CONFIG_CHANGE);
 495   EnterPendingState(DECODER_STOP);
 496   SatisfyPendingCallback(DEMUXER_READ_CONFIG_CHANGE);
 497   SatisfyPendingCallback(DECODER_STOP);
 498 }
 499
 500 TEST_P(VideoFrameStreamTest, Stop_DuringNormalDecoderRead) {
 501   Initialize();
 502   EnterPendingState(DECODER_READ);
 503   EnterPendingState(DECODER_STOP);
 504   SatisfyPendingCallback(DECODER_READ);
 505   SatisfyPendingCallback(DECODER_STOP);
 506 }
 507
 508 TEST_P(VideoFrameStreamTest, Stop_AfterNormalRead) {
 509   Initialize();
 510   Read();
 511   Stop();
 512 }
 513
 514 TEST_P(VideoFrameStreamTest, Stop_AfterConfigChangeRead) {
 515   Initialize();
 516   EnterPendingState(DEMUXER_READ_CONFIG_CHANGE);
 517   SatisfyPendingCallback(DEMUXER_READ_CONFIG_CHANGE);
 518   Stop();
 519 }
 520
 521 TEST_P(VideoFrameStreamTest, Stop_DuringNoKeyRead) {
 522   Initialize();
 523   EnterPendingState(DECRYPTOR_NO_KEY);
 524   Stop();
 525 }
 526
 527 TEST_P(VideoFrameStreamTest, Stop_DuringReset) {
 528   Initialize();
 529   EnterPendingState(DECODER_RESET);
 530   EnterPendingState(DECODER_STOP);
 531   SatisfyPendingCallback(DECODER_RESET);
 532   SatisfyPendingCallback(DECODER_STOP);
 533 }
 534
 535 TEST_P(VideoFrameStreamTest, Stop_AfterReset) {
 536   Initialize();
 537   Reset();
 538   Stop();
 539 }
 540
 541 TEST_P(VideoFrameStreamTest, Stop_DuringRead_DuringReset) {
 542   Initialize();
 543   EnterPendingState(DECODER_READ);
 544   EnterPendingState(DECODER_RESET);
 545   EnterPendingState(DECODER_STOP);
 546   SatisfyPendingCallback(DECODER_READ);
 547   SatisfyPendingCallback(DECODER_RESET);
 548   SatisfyPendingCallback(DECODER_STOP);
 549 }
 550
 551 TEST_P(VideoFrameStreamTest, Stop_AfterRead_DuringReset) {
 552   Initialize();
 553   EnterPendingState(DECODER_READ);
 554   EnterPendingState(DECODER_RESET);
 555   SatisfyPendingCallback(DECODER_READ);
 556   EnterPendingState(DECODER_STOP);
 557   SatisfyPendingCallback(DECODER_RESET);
 558   SatisfyPendingCallback(DECODER_STOP);
 559 }
 560
 561 TEST_P(VideoFrameStreamTest, Stop_AfterRead_AfterReset) {
 562   Initialize();
 563   Read();
 564   Reset();
 565   Stop();
 566 }
 567
 568 }  // namespace media