Home | History | Annotate | Download | only in base 
      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 #ifndef MEDIA_BASE_TEST_HELPERS_H_
      6 #define MEDIA_BASE_TEST_HELPERS_H_
      7 
      8 #include "base/basictypes.h"
      9 #include "base/callback.h"
     10 #include "media/base/pipeline_status.h"
     11 #include "media/base/sample_format.h"
     12 #include "media/base/video_decoder_config.h"
     13 #include "testing/gmock/include/gmock/gmock.h"
     14 #include "ui/gfx/size.h"
     15 
     16 namespace base {
     17 class MessageLoop;
     18 class TimeDelta;
     19 }
     20 
     21 namespace media {
     22 
     23 class AudioBuffer;
     24 class DecoderBuffer;
     25 
     26 // Return a callback that expects to be run once.
     27 base::Closure NewExpectedClosure();
     28 PipelineStatusCB NewExpectedStatusCB(PipelineStatus status);
     29 
     30 // Helper class for running a message loop until a callback has run. Useful for
     31 // testing classes that run on more than a single thread.
     32 //
     33 // Events are intended for single use and cannot be reset.
     34 class WaitableMessageLoopEvent {
     35  public:
     36   WaitableMessageLoopEvent();
     37   ~WaitableMessageLoopEvent();
     38 
     39   // Returns a thread-safe closure that will signal |this| when executed.
     40   base::Closure GetClosure();
     41   PipelineStatusCB GetPipelineStatusCB();
     42 
     43   // Runs the current message loop until |this| has been signaled.
     44   //
     45   // Fails the test if the timeout is reached.
     46   void RunAndWait();
     47 
     48   // Runs the current message loop until |this| has been signaled and asserts
     49   // that the |expected| status was received.
     50   //
     51   // Fails the test if the timeout is reached.
     52   void RunAndWaitForStatus(PipelineStatus expected);
     53 
     54  private:
     55   void OnCallback(PipelineStatus status);
     56   void OnTimeout();
     57 
     58   base::MessageLoop* message_loop_;
     59   bool signaled_;
     60   PipelineStatus status_;
     61 
     62   DISALLOW_COPY_AND_ASSIGN(WaitableMessageLoopEvent);
     63 };
     64 
     65 // Provides pre-canned VideoDecoderConfig. These types are used for tests that
     66 // don't care about detailed parameters of the config.
     67 class TestVideoConfig {
     68  public:
     69   // Returns a configuration that is invalid.
     70   static VideoDecoderConfig Invalid();
     71 
     72   static VideoDecoderConfig Normal();
     73   static VideoDecoderConfig NormalEncrypted();
     74 
     75   // Returns a configuration that is larger in dimensions than Normal().
     76   static VideoDecoderConfig Large();
     77   static VideoDecoderConfig LargeEncrypted();
     78 
     79   // Returns coded size for Normal and Large config.
     80   static gfx::Size NormalCodedSize();
     81   static gfx::Size LargeCodedSize();
     82 
     83  private:
     84   DISALLOW_IMPLICIT_CONSTRUCTORS(TestVideoConfig);
     85 };
     86 
     87 // Create an AudioBuffer containing |frames| frames of data, where each sample
     88 // is of type T. Each frame will have the data from |channels| channels
     89 // interleaved. |start| and |increment| are used to specify the values for the
     90 // samples. Since this is interleaved data, channel 0 data will be:
     91 //   |start|
     92 //   |start| + |channels| * |increment|
     93 //   |start| + 2 * |channels| * |increment|, and so on.
     94 // Data for subsequent channels is similar. No check is done that |format|
     95 // requires data to be of type T, but it is verified that |format| is an
     96 // interleaved format.
     97 //
     98 // |start_time| will be used as the start time for the samples. |duration| is
     99 // the duration.
    100 template <class T>
    101 scoped_refptr<AudioBuffer> MakeInterleavedAudioBuffer(
    102     SampleFormat format,
    103     int channels,
    104     T start,
    105     T increment,
    106     int frames,
    107     base::TimeDelta start_time,
    108     base::TimeDelta duration);
    109 
    110 // Create an AudioBuffer containing |frames| frames of data, where each sample
    111 // is of type T. Since this is planar data, there will be a block for each of
    112 // |channel| channels. |start| and |increment| are used to specify the values
    113 // for the samples, which are created in channel order. Since this is planar
    114 // data, channel 0 data will be:
    115 //   |start|
    116 //   |start| + |increment|
    117 //   |start| + 2 * |increment|, and so on.
    118 // Data for channel 1 will follow where channel 0 ends. Subsequent channels are
    119 // similar. No check is done that |format| requires data to be of type T, but it
    120 // is verified that |format| is a planar format.
    121 //
    122 // |start_time| will be used as the start time for the samples. |duration| is
    123 // the duration.
    124 template <class T>
    125 scoped_refptr<AudioBuffer> MakePlanarAudioBuffer(
    126     SampleFormat format,
    127     int channels,
    128     T start,
    129     T increment,
    130     int frames,
    131     base::TimeDelta start_time,
    132     base::TimeDelta duration);
    133 
    134 // Create a fake video DecoderBuffer for testing purpose. The buffer contains
    135 // part of video decoder config info embedded so that the testing code can do
    136 // some sanity check.
    137 scoped_refptr<DecoderBuffer> CreateFakeVideoBufferForTest(
    138     const VideoDecoderConfig& config,
    139     base::TimeDelta timestamp,
    140     base::TimeDelta duration);
    141 
    142 // Verify if a fake video DecoderBuffer is valid.
    143 bool VerifyFakeVideoBufferForTest(const scoped_refptr<DecoderBuffer>& buffer,
    144                                   const VideoDecoderConfig& config);
    145 
    146 }  // namespace media
    147 
    148 #endif  // MEDIA_BASE_TEST_HELPERS_H_
    149