media/base/test_helpers.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 "media/base/test_helpers.h"
   6
   7 #include "base/bind.h"
   8 #include "base/logging.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "base/pickle.h"
  11 #include "base/test/test_timeouts.h"
  12 #include "base/time/time.h"
  13 #include "base/timer/timer.h"
  14 #include "media/base/audio_buffer.h"
  15 #include "media/base/bind_to_loop.h"
  16 #include "media/base/decoder_buffer.h"
  17 #include "ui/gfx/rect.h"
  18
  19 using ::testing::_;
  20 using ::testing::StrictMock;
  21
  22 namespace media {
  23
  24 // Utility mock for testing methods expecting Closures and PipelineStatusCBs.
  25 class MockCallback : public base::RefCountedThreadSafe<MockCallback> {
  26  public:
  27   MockCallback();
  28   MOCK_METHOD0(Run, void());
  29   MOCK_METHOD1(RunWithStatus, void(PipelineStatus));
  30
  31  protected:
  32   friend class base::RefCountedThreadSafe<MockCallback>;
  33   virtual ~MockCallback();
  34
  35  private:
  36   DISALLOW_COPY_AND_ASSIGN(MockCallback);
  37 };
  38
  39 MockCallback::MockCallback() {}
  40 MockCallback::~MockCallback() {}
  41
  42 base::Closure NewExpectedClosure() {
  43   StrictMock<MockCallback>* callback = new StrictMock<MockCallback>();
  44   EXPECT_CALL(*callback, Run());
  45   return base::Bind(&MockCallback::Run, callback);
  46 }
  47
  48 PipelineStatusCB NewExpectedStatusCB(PipelineStatus status) {
  49   StrictMock<MockCallback>* callback = new StrictMock<MockCallback>();
  50   EXPECT_CALL(*callback, RunWithStatus(status));
  51   return base::Bind(&MockCallback::RunWithStatus, callback);
  52 }
  53
  54 WaitableMessageLoopEvent::WaitableMessageLoopEvent()
  55     : message_loop_(base::MessageLoop::current()),
  56       signaled_(false),
  57       status_(PIPELINE_OK) {
  58   DCHECK(message_loop_);
  59 }
  60
  61 WaitableMessageLoopEvent::~WaitableMessageLoopEvent() {}
  62
  63 base::Closure WaitableMessageLoopEvent::GetClosure() {
  64   DCHECK_EQ(message_loop_, base::MessageLoop::current());
  65   return BindToLoop(message_loop_->message_loop_proxy(), base::Bind(
  66       &WaitableMessageLoopEvent::OnCallback, base::Unretained(this),
  67       PIPELINE_OK));
  68 }
  69
  70 PipelineStatusCB WaitableMessageLoopEvent::GetPipelineStatusCB() {
  71   DCHECK_EQ(message_loop_, base::MessageLoop::current());
  72   return BindToLoop(message_loop_->message_loop_proxy(), base::Bind(
  73       &WaitableMessageLoopEvent::OnCallback, base::Unretained(this)));
  74 }
  75
  76 void WaitableMessageLoopEvent::RunAndWait() {
  77   RunAndWaitForStatus(PIPELINE_OK);
  78 }
  79
  80 void WaitableMessageLoopEvent::RunAndWaitForStatus(PipelineStatus expected) {
  81   DCHECK_EQ(message_loop_, base::MessageLoop::current());
  82   if (signaled_) {
  83     EXPECT_EQ(expected, status_);
  84     return;
  85   }
  86
  87   base::Timer timer(false, false);
  88   timer.Start(FROM_HERE, TestTimeouts::action_timeout(), base::Bind(
  89       &WaitableMessageLoopEvent::OnTimeout, base::Unretained(this)));
  90
  91   message_loop_->Run();
  92   EXPECT_TRUE(signaled_);
  93   EXPECT_EQ(expected, status_);
  94 }
  95
  96 void WaitableMessageLoopEvent::OnCallback(PipelineStatus status) {
  97   DCHECK_EQ(message_loop_, base::MessageLoop::current());
  98   signaled_ = true;
  99   status_ = status;
 100   message_loop_->QuitWhenIdle();
 101 }
 102
 103 void WaitableMessageLoopEvent::OnTimeout() {
 104   DCHECK_EQ(message_loop_, base::MessageLoop::current());
 105   ADD_FAILURE() << "Timed out waiting for message loop to quit";
 106   message_loop_->QuitWhenIdle();
 107 }
 108
 109 static VideoDecoderConfig GetTestConfig(VideoCodec codec,
 110                                         gfx::Size coded_size,
 111                                         bool is_encrypted) {
 112   gfx::Rect visible_rect(coded_size.width(), coded_size.height());
 113   gfx::Size natural_size = coded_size;
 114
 115   return VideoDecoderConfig(codec, VIDEO_CODEC_PROFILE_UNKNOWN,
 116       VideoFrame::YV12, coded_size, visible_rect, natural_size,
 117       NULL, 0, is_encrypted);
 118 }
 119
 120 static const gfx::Size kNormalSize(320, 240);
 121 static const gfx::Size kLargeSize(640, 480);
 122
 123 VideoDecoderConfig TestVideoConfig::Invalid() {
 124   return GetTestConfig(kUnknownVideoCodec, kNormalSize, false);
 125 }
 126
 127 VideoDecoderConfig TestVideoConfig::Normal() {
 128   return GetTestConfig(kCodecVP8, kNormalSize, false);
 129 }
 130
 131 VideoDecoderConfig TestVideoConfig::NormalEncrypted() {
 132   return GetTestConfig(kCodecVP8, kNormalSize, true);
 133 }
 134
 135 VideoDecoderConfig TestVideoConfig::Large() {
 136   return GetTestConfig(kCodecVP8, kLargeSize, false);
 137 }
 138
 139 VideoDecoderConfig TestVideoConfig::LargeEncrypted() {
 140   return GetTestConfig(kCodecVP8, kLargeSize, true);
 141 }
 142
 143 gfx::Size TestVideoConfig::NormalCodedSize() {
 144   return kNormalSize;
 145 }
 146
 147 gfx::Size TestVideoConfig::LargeCodedSize() {
 148   return kLargeSize;
 149 }
 150
 151 template <class T>
 152 scoped_refptr<AudioBuffer> MakeInterleavedAudioBuffer(
 153     SampleFormat format,
 154     int channels,
 155     T start,
 156     T increment,
 157     int frames,
 158     base::TimeDelta start_time,
 159     base::TimeDelta duration) {
 160   DCHECK(format == kSampleFormatU8 || format == kSampleFormatS16 ||
 161          format == kSampleFormatS32 || format == kSampleFormatF32);
 162
 163   // Create a block of memory with values:
 164   //   start
 165   //   start + increment
 166   //   start + 2 * increment, ...
 167   // Since this is interleaved data, channel 0 data will be:
 168   //   start
 169   //   start + channels * increment
 170   //   start + 2 * channels * increment, ...
 171   int buffer_size = frames * channels * sizeof(T);
 172   scoped_ptr<uint8[]> memory(new uint8[buffer_size]);
 173   uint8* data[] = { memory.get() };
 174   T* buffer = reinterpret_cast<T*>(memory.get());
 175   for (int i = 0; i < frames * channels; ++i) {
 176     buffer[i] = start;
 177     start += increment;
 178   }
 179   return AudioBuffer::CopyFrom(
 180       format, channels, frames, data, start_time, duration);
 181 }
 182
 183 template <class T>
 184 scoped_refptr<AudioBuffer> MakePlanarAudioBuffer(
 185     SampleFormat format,
 186     int channels,
 187     T start,
 188     T increment,
 189     int frames,
 190     base::TimeDelta start_time,
 191     base::TimeDelta duration) {
 192   DCHECK(format == kSampleFormatPlanarF32 || format == kSampleFormatPlanarS16);
 193
 194   // Create multiple blocks of data, one for each channel.
 195   // Values in channel 0 will be:
 196   //   start
 197   //   start + increment
 198   //   start + 2 * increment, ...
 199   // Values in channel 1 will be:
 200   //   start + frames * increment
 201   //   start + (frames + 1) * increment
 202   //   start + (frames + 2) * increment, ...
 203   int buffer_size = frames * sizeof(T);
 204   scoped_ptr<uint8*[]> data(new uint8*[channels]);
 205   scoped_ptr<uint8[]> memory(new uint8[channels * buffer_size]);
 206   for (int i = 0; i < channels; ++i) {
 207     data.get()[i] = memory.get() + i * buffer_size;
 208     T* buffer = reinterpret_cast<T*>(data.get()[i]);
 209     for (int j = 0; j < frames; ++j) {
 210       buffer[j] = start;
 211       start += increment;
 212     }
 213   }
 214   return AudioBuffer::CopyFrom(
 215       format, channels, frames, data.get(), start_time, duration);
 216 }
 217
 218 // Instantiate all the types of MakeInterleavedAudioBuffer() and
 219 // MakePlanarAudioBuffer() needed.
 220
 221 #define DEFINE_INTERLEAVED_INSTANCE(type)                               \
 222   template scoped_refptr<AudioBuffer> MakeInterleavedAudioBuffer<type>( \
 223       SampleFormat format,                                              \
 224       int channels,                                                     \
 225       type start,                                                       \
 226       type increment,                                                   \
 227       int frames,                                                       \
 228       base::TimeDelta start_time,                                       \
 229       base::TimeDelta duration)
 230 DEFINE_INTERLEAVED_INSTANCE(uint8);
 231 DEFINE_INTERLEAVED_INSTANCE(int16);
 232 DEFINE_INTERLEAVED_INSTANCE(int32);
 233 DEFINE_INTERLEAVED_INSTANCE(float);
 234
 235 #define DEFINE_PLANAR_INSTANCE(type)                               \
 236   template scoped_refptr<AudioBuffer> MakePlanarAudioBuffer<type>( \
 237       SampleFormat format,                                         \
 238       int channels,                                                \
 239       type start,                                                  \
 240       type increment,                                              \
 241       int frames,                                                  \
 242       base::TimeDelta start_time,                                  \
 243       base::TimeDelta duration);
 244 DEFINE_PLANAR_INSTANCE(int16);
 245 DEFINE_PLANAR_INSTANCE(float);
 246
 247 static const char kFakeVideoBufferHeader[] = "FakeVideoBufferForTest";
 248
 249 scoped_refptr<DecoderBuffer> CreateFakeVideoBufferForTest(
 250     const VideoDecoderConfig& config,
 251     base::TimeDelta timestamp, base::TimeDelta duration) {
 252   Pickle pickle;
 253   pickle.WriteString(kFakeVideoBufferHeader);
 254   pickle.WriteInt(config.coded_size().width());
 255   pickle.WriteInt(config.coded_size().height());
 256   pickle.WriteInt64(timestamp.InMilliseconds());
 257
 258   scoped_refptr<DecoderBuffer> buffer = DecoderBuffer::CopyFrom(
 259       static_cast<const uint8*>(pickle.data()),
 260       static_cast<int>(pickle.size()));
 261   buffer->set_timestamp(timestamp);
 262   buffer->set_duration(duration);
 263
 264   return buffer;
 265 }
 266
 267 bool VerifyFakeVideoBufferForTest(
 268     const scoped_refptr<DecoderBuffer>& buffer,
 269     const VideoDecoderConfig& config) {
 270   // Check if the input |buffer| matches the |config|.
 271   PickleIterator pickle(Pickle(reinterpret_cast<const char*>(buffer->data()),
 272                                buffer->data_size()));
 273   std::string header;
 274   int width = 0;
 275   int height = 0;
 276   bool success = pickle.ReadString(&header) && pickle.ReadInt(&width) &&
 277                  pickle.ReadInt(&height);
 278   return (success && header == kFakeVideoBufferHeader &&
 279           width == config.coded_size().width() &&
 280           height == config.coded_size().height());
 281 }
 282
 283 }  // namespace media