chromecast/media/cma/backend/audio_video_pipeline_device_unittest.cc

   1 // Copyright 2014 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 <vector>
   6
   7 #include "base/basictypes.h"
   8 #include "base/bind.h"
   9 #include "base/command_line.h"
  10 #include "base/files/file_path.h"
  11 #include "base/files/memory_mapped_file.h"
  12 #include "base/logging.h"
  13 #include "base/memory/ref_counted.h"
  14 #include "base/memory/scoped_ptr.h"
  15 #include "base/memory/scoped_vector.h"
  16 #include "base/message_loop/message_loop.h"
  17 #include "base/path_service.h"
  18 #include "base/single_thread_task_runner.h"
  19 #include "base/thread_task_runner_handle.h"
  20 #include "base/threading/thread.h"
  21 #include "base/time/time.h"
  22 #include "chromecast/media/base/decrypt_context.h"
  23 #include "chromecast/media/cma/backend/audio_pipeline_device.h"
  24 #include "chromecast/media/cma/backend/media_clock_device.h"
  25 #include "chromecast/media/cma/backend/media_pipeline_device.h"
  26 #include "chromecast/media/cma/backend/media_pipeline_device_factory.h"
  27 #include "chromecast/media/cma/backend/media_pipeline_device_params.h"
  28 #include "chromecast/media/cma/backend/video_pipeline_device.h"
  29 #include "chromecast/media/cma/base/decoder_buffer_adapter.h"
  30 #include "chromecast/media/cma/base/decoder_buffer_base.h"
  31 #include "chromecast/media/cma/base/decoder_config_adapter.h"
  32 #include "chromecast/media/cma/test/frame_segmenter_for_test.h"
  33 #include "chromecast/media/cma/test/media_component_device_feeder_for_test.h"
  34 #include "chromecast/public/cast_media_shlib.h"
  35 #include "chromecast/public/media/decoder_config.h"
  36 #include "media/base/audio_decoder_config.h"
  37 #include "media/base/buffers.h"
  38 #include "media/base/decoder_buffer.h"
  39 #include "media/base/video_decoder_config.h"
  40 #include "testing/gtest/include/gtest/gtest.h"
  41
  42 namespace chromecast {
  43 namespace media {
  44
  45 namespace {
  46
  47 typedef ScopedVector<MediaComponentDeviceFeederForTest>::iterator
  48     ComponentDeviceIterator;
  49
  50 const base::TimeDelta kMonitorLoopDelay = base::TimeDelta::FromMilliseconds(20);
  51
  52 base::FilePath GetTestDataFilePath(const std::string& name) {
  53   base::FilePath file_path;
  54   CHECK(PathService::Get(base::DIR_SOURCE_ROOT, &file_path));
  55
  56   file_path = file_path.Append(FILE_PATH_LITERAL("media"))
  57       .Append(FILE_PATH_LITERAL("test")).Append(FILE_PATH_LITERAL("data"))
  58       .AppendASCII(name);
  59   return file_path;
  60 }
  61
  62 }  // namespace
  63
  64 class AudioVideoPipelineDeviceTest : public testing::Test {
  65  public:
  66   struct PauseInfo {
  67     PauseInfo() {}
  68     PauseInfo(base::TimeDelta d, base::TimeDelta l) : delay(d), length(l) {}
  69     ~PauseInfo() {}
  70
  71     base::TimeDelta delay;
  72     base::TimeDelta length;
  73   };
  74
  75   AudioVideoPipelineDeviceTest();
  76   ~AudioVideoPipelineDeviceTest() override;
  77
  78   void SetUp() override {
  79     CastMediaShlib::Initialize(
  80         base::CommandLine::ForCurrentProcess()->argv());
  81   }
  82
  83   void TearDown() override {
  84     CastMediaShlib::Finalize();
  85   }
  86
  87   void ConfigureForFile(std::string filename);
  88   void ConfigureForAudioOnly(std::string filename);
  89   void ConfigureForVideoOnly(std::string filename, bool raw_h264);
  90
  91   // Pattern loops, waiting >= pattern[i].delay against media clock between
  92   // pauses, then pausing for >= pattern[i].length against MessageLoop
  93   // A pause with delay <0 signals to stop sequence and do not loop
  94   void SetPausePattern(const std::vector<PauseInfo> pattern);
  95
  96   // Adds a pause to the end of pause pattern
  97   void AddPause(base::TimeDelta delay, base::TimeDelta length);
  98
  99   void Start();
 100
 101  private:
 102   void Initialize();
 103
 104   void LoadAudioStream(std::string filename);
 105   void LoadVideoStream(std::string filename, bool raw_h264);
 106
 107   void MonitorLoop();
 108
 109   void OnPauseCompleted();
 110
 111   void OnEos(MediaComponentDeviceFeederForTest* device_feeder);
 112
 113   scoped_ptr<MediaPipelineDevice> media_pipeline_device_;
 114   MediaClockDevice* media_clock_device_;
 115
 116   // Devices to feed
 117   ScopedVector<MediaComponentDeviceFeederForTest>
 118       component_device_feeders_;
 119
 120   // Current media time.
 121   base::TimeDelta pause_time_;
 122
 123   // Pause settings
 124   std::vector<PauseInfo> pause_pattern_;
 125   int pause_pattern_idx_;
 126
 127   DISALLOW_COPY_AND_ASSIGN(AudioVideoPipelineDeviceTest);
 128 };
 129
 130 AudioVideoPipelineDeviceTest::AudioVideoPipelineDeviceTest()
 131     : pause_pattern_() {
 132 }
 133
 134 AudioVideoPipelineDeviceTest::~AudioVideoPipelineDeviceTest() {
 135 }
 136
 137 void AudioVideoPipelineDeviceTest::AddPause(base::TimeDelta delay,
 138                                             base::TimeDelta length) {
 139   pause_pattern_.push_back(PauseInfo(delay, length));
 140 }
 141
 142 void AudioVideoPipelineDeviceTest::SetPausePattern(
 143     const std::vector<PauseInfo> pattern) {
 144   pause_pattern_ = pattern;
 145 }
 146
 147 void AudioVideoPipelineDeviceTest::ConfigureForAudioOnly(std::string filename) {
 148   Initialize();
 149   LoadAudioStream(filename);
 150 }
 151
 152 void AudioVideoPipelineDeviceTest::ConfigureForVideoOnly(std::string filename,
 153                                                          bool raw_h264) {
 154   Initialize();
 155   LoadVideoStream(filename, raw_h264);
 156 }
 157
 158 void AudioVideoPipelineDeviceTest::ConfigureForFile(std::string filename) {
 159   Initialize();
 160   LoadVideoStream(filename, false /* raw_h264 */);
 161   LoadAudioStream(filename);
 162 }
 163
 164 void AudioVideoPipelineDeviceTest::LoadAudioStream(std::string filename) {
 165   base::FilePath file_path = GetTestDataFilePath(filename);
 166   DemuxResult demux_result = FFmpegDemuxForTest(file_path, true /* audio */);
 167   BufferList frames = demux_result.frames;
 168
 169   AudioPipelineDevice* audio_pipeline_device =
 170       media_pipeline_device_->GetAudioPipelineDevice();
 171
 172   bool success = audio_pipeline_device->SetConfig(
 173       DecoderConfigAdapter::ToCastAudioConfig(kPrimary,
 174                                               demux_result.audio_config));
 175   ASSERT_TRUE(success);
 176
 177   VLOG(2) << "Got " << frames.size() << " audio input frames";
 178
 179   frames.push_back(
 180       scoped_refptr<DecoderBufferBase>(
 181           new DecoderBufferAdapter(::media::DecoderBuffer::CreateEOSBuffer())));
 182
 183   MediaComponentDeviceFeederForTest* device_feeder =
 184       new MediaComponentDeviceFeederForTest(audio_pipeline_device, frames);
 185   device_feeder->Initialize(base::Bind(&AudioVideoPipelineDeviceTest::OnEos,
 186                                        base::Unretained(this),
 187                                        device_feeder));
 188   component_device_feeders_.push_back(device_feeder);
 189 }
 190
 191 void AudioVideoPipelineDeviceTest::LoadVideoStream(std::string filename,
 192                                                    bool raw_h264) {
 193   BufferList frames;
 194   VideoConfig video_config;
 195
 196   if (raw_h264) {
 197     base::FilePath file_path = GetTestDataFilePath(filename);
 198     base::MemoryMappedFile video_stream;
 199     ASSERT_TRUE(video_stream.Initialize(file_path))
 200         << "Couldn't open stream file: " << file_path.MaybeAsASCII();
 201     frames = H264SegmenterForTest(video_stream.data(), video_stream.length());
 202
 203     // TODO(erickung): Either pull data from stream or make caller specify value
 204     video_config.codec = kCodecH264;
 205     video_config.profile = kH264Main;
 206     video_config.additional_config = NULL;
 207     video_config.is_encrypted = false;
 208   } else {
 209     base::FilePath file_path = GetTestDataFilePath(filename);
 210     DemuxResult demux_result = FFmpegDemuxForTest(file_path,
 211                                                   /*audio*/ false);
 212     frames = demux_result.frames;
 213     video_config = DecoderConfigAdapter::ToCastVideoConfig(
 214         kPrimary, demux_result.video_config);
 215   }
 216
 217   VideoPipelineDevice* video_pipeline_device =
 218       media_pipeline_device_->GetVideoPipelineDevice();
 219
 220   // Set configuration.
 221   bool success = video_pipeline_device->SetConfig(video_config);
 222   ASSERT_TRUE(success);
 223
 224   VLOG(2) << "Got " << frames.size() << " video input frames";
 225
 226   frames.push_back(
 227       scoped_refptr<DecoderBufferBase>(new DecoderBufferAdapter(
 228           ::media::DecoderBuffer::CreateEOSBuffer())));
 229
 230   MediaComponentDeviceFeederForTest* device_feeder =
 231       new MediaComponentDeviceFeederForTest(video_pipeline_device, frames);
 232   device_feeder->Initialize(base::Bind(&AudioVideoPipelineDeviceTest::OnEos,
 233                                        base::Unretained(this),
 234                                        device_feeder));
 235   component_device_feeders_.push_back(device_feeder);
 236 }
 237
 238 void AudioVideoPipelineDeviceTest::Start() {
 239   pause_time_ = base::TimeDelta();
 240   pause_pattern_idx_ = 0;
 241
 242   for (size_t i = 0; i < component_device_feeders_.size(); i++) {
 243     base::ThreadTaskRunnerHandle::Get()->PostTask(
 244         FROM_HERE, base::Bind(&MediaComponentDeviceFeederForTest::Feed,
 245                               base::Unretained(component_device_feeders_[i])));
 246   }
 247
 248   media_clock_device_->SetState(MediaClockDevice::kStateRunning);
 249
 250   base::ThreadTaskRunnerHandle::Get()->PostTask(
 251       FROM_HERE, base::Bind(&AudioVideoPipelineDeviceTest::MonitorLoop,
 252                             base::Unretained(this)));
 253 }
 254
 255 void AudioVideoPipelineDeviceTest::MonitorLoop() {
 256   base::TimeDelta media_time = media_clock_device_->GetTime();
 257
 258   if (!pause_pattern_.empty() &&
 259       pause_pattern_[pause_pattern_idx_].delay >= base::TimeDelta() &&
 260       media_time >= pause_time_ + pause_pattern_[pause_pattern_idx_].delay) {
 261     // Do Pause
 262     media_clock_device_->SetRate(0.0);
 263     pause_time_ = media_clock_device_->GetTime();
 264
 265     VLOG(2) << "Pausing at " << pause_time_.InMilliseconds() << "ms for " <<
 266         pause_pattern_[pause_pattern_idx_].length.InMilliseconds() << "ms";
 267
 268     // Wait for pause finish
 269     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
 270         FROM_HERE, base::Bind(&AudioVideoPipelineDeviceTest::OnPauseCompleted,
 271                               base::Unretained(this)),
 272         pause_pattern_[pause_pattern_idx_].length);
 273     return;
 274   }
 275
 276   // Check state again in a little while
 277   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
 278       FROM_HERE, base::Bind(&AudioVideoPipelineDeviceTest::MonitorLoop,
 279                             base::Unretained(this)),
 280       kMonitorLoopDelay);
 281 }
 282
 283 void AudioVideoPipelineDeviceTest::OnPauseCompleted() {
 284   // Make sure the media time didn't move during that time.
 285   base::TimeDelta media_time = media_clock_device_->GetTime();
 286
 287   // TODO(damienv):
 288   // Should be:
 289   // EXPECT_EQ(media_time, media_time_);
 290   // However, some backends, when rendering the first frame while in paused
 291   // mode moves the time forward.
 292   // This behaviour is not intended.
 293   EXPECT_GE(media_time, pause_time_);
 294   EXPECT_LE(media_time, pause_time_ + base::TimeDelta::FromMilliseconds(50));
 295
 296   pause_time_ = media_time;
 297   pause_pattern_idx_ = (pause_pattern_idx_ + 1) % pause_pattern_.size();
 298
 299   VLOG(2) << "Pause complete, restarting media clock";
 300
 301   // Resume playback and frame feeding.
 302   media_clock_device_->SetRate(1.0);
 303
 304   MonitorLoop();
 305 }
 306
 307 void AudioVideoPipelineDeviceTest::OnEos(
 308     MediaComponentDeviceFeederForTest* device_feeder) {
 309   for (ComponentDeviceIterator it = component_device_feeders_.begin();
 310        it != component_device_feeders_.end();
 311        ++it) {
 312     if (*it == device_feeder) {
 313       component_device_feeders_.erase(it);
 314       break;
 315     }
 316   }
 317
 318   // Check if all streams finished
 319   if (component_device_feeders_.empty())
 320     base::MessageLoop::current()->QuitWhenIdle();
 321 }
 322
 323 void AudioVideoPipelineDeviceTest::Initialize() {
 324   // Create the media device.
 325   MediaPipelineDeviceParams params;
 326   scoped_ptr<MediaPipelineDeviceFactory> device_factory =
 327       GetMediaPipelineDeviceFactory(params);
 328   media_pipeline_device_.reset(new MediaPipelineDevice(device_factory.Pass()));
 329   media_clock_device_ = media_pipeline_device_->GetMediaClockDevice();
 330
 331   // Clock initialization and configuration.
 332   bool success =
 333       media_clock_device_->SetState(MediaClockDevice::kStateIdle);
 334   ASSERT_TRUE(success);
 335   success = media_clock_device_->ResetTimeline(base::TimeDelta());
 336   ASSERT_TRUE(success);
 337   media_clock_device_->SetRate(1.0);
 338 }
 339
 340 TEST_F(AudioVideoPipelineDeviceTest, Mp3Playback) {
 341   scoped_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
 342
 343   ConfigureForAudioOnly("sfx.mp3");
 344   Start();
 345   message_loop->Run();
 346 }
 347
 348 TEST_F(AudioVideoPipelineDeviceTest, VorbisPlayback) {
 349   scoped_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
 350
 351   ConfigureForAudioOnly("sfx.ogg");
 352   Start();
 353   message_loop->Run();
 354 }
 355
 356 TEST_F(AudioVideoPipelineDeviceTest, H264Playback) {
 357   scoped_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
 358
 359   ConfigureForVideoOnly("bear.h264", true /* raw_h264 */);
 360   Start();
 361   message_loop->Run();
 362 }
 363
 364 TEST_F(AudioVideoPipelineDeviceTest, WebmPlaybackWithPause) {
 365   scoped_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
 366
 367   // Setup to pause for 100ms every 500ms
 368   AddPause(base::TimeDelta::FromMilliseconds(500),
 369            base::TimeDelta::FromMilliseconds(100));
 370
 371   ConfigureForVideoOnly("bear-640x360.webm", false /* raw_h264 */);
 372   Start();
 373   message_loop->Run();
 374 }
 375
 376 TEST_F(AudioVideoPipelineDeviceTest, Vp8Playback) {
 377   scoped_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
 378
 379   ConfigureForVideoOnly("bear-vp8a.webm", false /* raw_h264 */);
 380   Start();
 381   message_loop->Run();
 382 }
 383
 384 TEST_F(AudioVideoPipelineDeviceTest, WebmPlayback) {
 385   scoped_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
 386
 387   ConfigureForFile("bear-640x360.webm");
 388   Start();
 389   message_loop->Run();
 390 }
 391
 392 }  // namespace media
 393 }  // namespace chromecast