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 #include "base/memory/scoped_ptr.h"
      6 #include "media/base/audio_buffer.h"
      7 #include "media/base/audio_bus.h"
      8 #include "media/base/audio_splicer.h"
      9 #include "media/base/audio_timestamp_helper.h"
     10 #include "media/base/buffers.h"
     11 #include "media/base/test_helpers.h"
     12 #include "testing/gtest/include/gtest/gtest.h"
     13 
     14 namespace media {
     15 
     16 static const SampleFormat kSampleFormat = kSampleFormatF32;
     17 static const int kChannels = 1;
     18 static const int kDefaultSampleRate = 44100;
     19 static const int kDefaultBufferSize = 100;
     20 
     21 class AudioSplicerTest : public ::testing::Test {
     22  public:
     23   AudioSplicerTest()
     24       : splicer_(kDefaultSampleRate),
     25         input_timestamp_helper_(kDefaultSampleRate) {
     26     input_timestamp_helper_.SetBaseTimestamp(base::TimeDelta());
     27   }
     28 
     29   scoped_refptr<AudioBuffer> GetNextInputBuffer(float value) {
     30     return GetNextInputBuffer(value, kDefaultBufferSize);
     31   }
     32 
     33   scoped_refptr<AudioBuffer> GetNextInputBuffer(float value, int frame_size) {
     34     scoped_refptr<AudioBuffer> buffer = MakeInterleavedAudioBuffer<float>(
     35         kSampleFormat,
     36         kChannels,
     37         value,
     38         0.0f,
     39         frame_size,
     40         input_timestamp_helper_.GetTimestamp(),
     41         input_timestamp_helper_.GetFrameDuration(frame_size));
     42     input_timestamp_helper_.AddFrames(frame_size);
     43     return buffer;
     44   }
     45 
     46   bool VerifyData(scoped_refptr<AudioBuffer> buffer, float value) {
     47     int frames = buffer->frame_count();
     48     scoped_ptr<AudioBus> bus = AudioBus::Create(kChannels, frames);
     49     buffer->ReadFrames(frames, 0, 0, bus.get());
     50     for (int i = 0; i < frames; ++i) {
     51       if (bus->channel(0)[i] != value)
     52         return false;
     53     }
     54     return true;
     55   }
     56 
     57  protected:
     58   AudioSplicer splicer_;
     59   AudioTimestampHelper input_timestamp_helper_;
     60 
     61   DISALLOW_COPY_AND_ASSIGN(AudioSplicerTest);
     62 };
     63 
     64 TEST_F(AudioSplicerTest, PassThru) {
     65   EXPECT_FALSE(splicer_.HasNextBuffer());
     66 
     67   // Test single buffer pass-thru behavior.
     68   scoped_refptr<AudioBuffer> input_1 = GetNextInputBuffer(0.1f);
     69   EXPECT_TRUE(splicer_.AddInput(input_1));
     70   EXPECT_TRUE(splicer_.HasNextBuffer());
     71 
     72   scoped_refptr<AudioBuffer> output_1 = splicer_.GetNextBuffer();
     73   EXPECT_FALSE(splicer_.HasNextBuffer());
     74   EXPECT_EQ(input_1->timestamp(), output_1->timestamp());
     75   EXPECT_EQ(input_1->duration(), output_1->duration());
     76   EXPECT_EQ(input_1->frame_count(), output_1->frame_count());
     77   EXPECT_TRUE(VerifyData(output_1, 0.1f));
     78 
     79   // Test that multiple buffers can be queued in the splicer.
     80   scoped_refptr<AudioBuffer> input_2 = GetNextInputBuffer(0.2f);
     81   scoped_refptr<AudioBuffer> input_3 = GetNextInputBuffer(0.3f);
     82   EXPECT_TRUE(splicer_.AddInput(input_2));
     83   EXPECT_TRUE(splicer_.AddInput(input_3));
     84   EXPECT_TRUE(splicer_.HasNextBuffer());
     85 
     86   scoped_refptr<AudioBuffer> output_2 = splicer_.GetNextBuffer();
     87   EXPECT_TRUE(splicer_.HasNextBuffer());
     88   EXPECT_EQ(input_2->timestamp(), output_2->timestamp());
     89   EXPECT_EQ(input_2->duration(), output_2->duration());
     90   EXPECT_EQ(input_2->frame_count(), output_2->frame_count());
     91 
     92   scoped_refptr<AudioBuffer> output_3 = splicer_.GetNextBuffer();
     93   EXPECT_FALSE(splicer_.HasNextBuffer());
     94   EXPECT_EQ(input_3->timestamp(), output_3->timestamp());
     95   EXPECT_EQ(input_3->duration(), output_3->duration());
     96   EXPECT_EQ(input_3->frame_count(), output_3->frame_count());
     97 }
     98 
     99 TEST_F(AudioSplicerTest, Reset) {
    100   scoped_refptr<AudioBuffer> input_1 = GetNextInputBuffer(0.1f);
    101   EXPECT_TRUE(splicer_.AddInput(input_1));
    102   EXPECT_TRUE(splicer_.HasNextBuffer());
    103 
    104   splicer_.Reset();
    105   EXPECT_FALSE(splicer_.HasNextBuffer());
    106 
    107   // Add some bytes to the timestamp helper so that the
    108   // next buffer starts many frames beyond the end of
    109   // |input_1|. This is to make sure that Reset() actually
    110   // clears its state and doesn't try to insert a gap.
    111   input_timestamp_helper_.AddFrames(100);
    112 
    113   // Verify that a new input buffer passes through as expected.
    114   scoped_refptr<AudioBuffer> input_2 = GetNextInputBuffer(0.2f);
    115   EXPECT_TRUE(splicer_.AddInput(input_2));
    116   EXPECT_TRUE(splicer_.HasNextBuffer());
    117 
    118   scoped_refptr<AudioBuffer> output_2 = splicer_.GetNextBuffer();
    119   EXPECT_FALSE(splicer_.HasNextBuffer());
    120   EXPECT_EQ(input_2->timestamp(), output_2->timestamp());
    121   EXPECT_EQ(input_2->duration(), output_2->duration());
    122   EXPECT_EQ(input_2->frame_count(), output_2->frame_count());
    123 }
    124 
    125 TEST_F(AudioSplicerTest, EndOfStream) {
    126   scoped_refptr<AudioBuffer> input_1 = GetNextInputBuffer(0.1f);
    127   scoped_refptr<AudioBuffer> input_2 = AudioBuffer::CreateEOSBuffer();
    128   scoped_refptr<AudioBuffer> input_3 = GetNextInputBuffer(0.2f);
    129   EXPECT_TRUE(input_2->end_of_stream());
    130 
    131   EXPECT_TRUE(splicer_.AddInput(input_1));
    132   EXPECT_TRUE(splicer_.AddInput(input_2));
    133   EXPECT_TRUE(splicer_.HasNextBuffer());
    134 
    135   scoped_refptr<AudioBuffer> output_1 = splicer_.GetNextBuffer();
    136   scoped_refptr<AudioBuffer> output_2 = splicer_.GetNextBuffer();
    137   EXPECT_FALSE(splicer_.HasNextBuffer());
    138   EXPECT_EQ(input_1->timestamp(), output_1->timestamp());
    139   EXPECT_EQ(input_1->duration(), output_1->duration());
    140   EXPECT_EQ(input_1->frame_count(), output_1->frame_count());
    141 
    142   EXPECT_TRUE(output_2->end_of_stream());
    143 
    144   // Verify that buffers can be added again after Reset().
    145   splicer_.Reset();
    146   EXPECT_TRUE(splicer_.AddInput(input_3));
    147   scoped_refptr<AudioBuffer> output_3 = splicer_.GetNextBuffer();
    148   EXPECT_FALSE(splicer_.HasNextBuffer());
    149   EXPECT_EQ(input_3->timestamp(), output_3->timestamp());
    150   EXPECT_EQ(input_3->duration(), output_3->duration());
    151   EXPECT_EQ(input_3->frame_count(), output_3->frame_count());
    152 }
    153 
    154 
    155 // Test the gap insertion code.
    156 // +--------------+    +--------------+
    157 // |11111111111111|    |22222222222222|
    158 // +--------------+    +--------------+
    159 // Results in:
    160 // +--------------+----+--------------+
    161 // |11111111111111|0000|22222222222222|
    162 // +--------------+----+--------------+
    163 TEST_F(AudioSplicerTest, GapInsertion) {
    164   scoped_refptr<AudioBuffer> input_1 = GetNextInputBuffer(0.1f);
    165 
    166   // Add bytes to the timestamp helper so that the next buffer
    167   // will have a starting timestamp that indicates a gap is
    168   // present.
    169   const int kGapSize = 7;
    170   input_timestamp_helper_.AddFrames(kGapSize);
    171   scoped_refptr<AudioBuffer> input_2 = GetNextInputBuffer(0.2f);
    172 
    173   EXPECT_TRUE(splicer_.AddInput(input_1));
    174   EXPECT_TRUE(splicer_.AddInput(input_2));
    175 
    176   // Verify that a gap buffer is generated.
    177   EXPECT_TRUE(splicer_.HasNextBuffer());
    178   scoped_refptr<AudioBuffer> output_1 = splicer_.GetNextBuffer();
    179   scoped_refptr<AudioBuffer> output_2 = splicer_.GetNextBuffer();
    180   scoped_refptr<AudioBuffer> output_3 = splicer_.GetNextBuffer();
    181   EXPECT_FALSE(splicer_.HasNextBuffer());
    182 
    183   // Verify that the first input buffer passed through unmodified.
    184   EXPECT_EQ(input_1->timestamp(), output_1->timestamp());
    185   EXPECT_EQ(input_1->duration(), output_1->duration());
    186   EXPECT_EQ(input_1->frame_count(), output_1->frame_count());
    187   EXPECT_TRUE(VerifyData(output_1, 0.1f));
    188 
    189   // Verify the contents of the gap buffer.
    190   base::TimeDelta gap_timestamp =
    191       input_1->timestamp() + input_1->duration();
    192   base::TimeDelta gap_duration = input_2->timestamp() - gap_timestamp;
    193   EXPECT_GT(gap_duration, base::TimeDelta());
    194   EXPECT_EQ(gap_timestamp, output_2->timestamp());
    195   EXPECT_EQ(gap_duration, output_2->duration());
    196   EXPECT_EQ(kGapSize, output_2->frame_count());
    197   EXPECT_TRUE(VerifyData(output_2, 0.0f));
    198 
    199   // Verify that the second input buffer passed through unmodified.
    200   EXPECT_EQ(input_2->timestamp(), output_3->timestamp());
    201   EXPECT_EQ(input_2->duration(), output_3->duration());
    202   EXPECT_EQ(input_2->frame_count(), output_3->frame_count());
    203   EXPECT_TRUE(VerifyData(output_3, 0.2f));
    204 }
    205 
    206 
    207 // Test that an error is signalled when the gap between input buffers is
    208 // too large.
    209 TEST_F(AudioSplicerTest, GapTooLarge) {
    210   scoped_refptr<AudioBuffer> input_1 = GetNextInputBuffer(0.1f);
    211 
    212   // Add a seconds worth of bytes so that an unacceptably large
    213   // gap exists between |input_1| and |input_2|.
    214   const int kGapSize = kDefaultSampleRate;
    215   input_timestamp_helper_.AddFrames(kGapSize);
    216   scoped_refptr<AudioBuffer> input_2 = GetNextInputBuffer(0.2f);
    217 
    218   EXPECT_TRUE(splicer_.AddInput(input_1));
    219   EXPECT_FALSE(splicer_.AddInput(input_2));
    220 
    221   EXPECT_TRUE(splicer_.HasNextBuffer());
    222   scoped_refptr<AudioBuffer> output_1 = splicer_.GetNextBuffer();
    223 
    224   // Verify that the first input buffer passed through unmodified.
    225   EXPECT_EQ(input_1->timestamp(), output_1->timestamp());
    226   EXPECT_EQ(input_1->duration(), output_1->duration());
    227   EXPECT_EQ(input_1->frame_count(), output_1->frame_count());
    228   EXPECT_TRUE(VerifyData(output_1, 0.1f));
    229 
    230   // Verify that the second buffer is not available.
    231   EXPECT_FALSE(splicer_.HasNextBuffer());
    232 
    233   // Reset the timestamp helper so it can generate a buffer that is
    234   // right after |input_1|.
    235   input_timestamp_helper_.SetBaseTimestamp(
    236       input_1->timestamp() + input_1->duration());
    237 
    238   // Verify that valid buffers are still accepted.
    239   scoped_refptr<AudioBuffer> input_3 = GetNextInputBuffer(0.3f);
    240   EXPECT_TRUE(splicer_.AddInput(input_3));
    241   EXPECT_TRUE(splicer_.HasNextBuffer());
    242   scoped_refptr<AudioBuffer> output_2 = splicer_.GetNextBuffer();
    243   EXPECT_FALSE(splicer_.HasNextBuffer());
    244   EXPECT_EQ(input_3->timestamp(), output_2->timestamp());
    245   EXPECT_EQ(input_3->duration(), output_2->duration());
    246   EXPECT_EQ(input_3->frame_count(), output_2->frame_count());
    247   EXPECT_TRUE(VerifyData(output_2, 0.3f));
    248 }
    249 
    250 
    251 // Verifies that an error is signalled if AddInput() is called
    252 // with a timestamp that is earlier than the first buffer added.
    253 TEST_F(AudioSplicerTest, BufferAddedBeforeBase) {
    254   input_timestamp_helper_.SetBaseTimestamp(
    255       base::TimeDelta::FromMicroseconds(10));
    256   scoped_refptr<AudioBuffer> input_1 = GetNextInputBuffer(0.1f);
    257 
    258   // Reset the timestamp helper so the next buffer will have a timestamp earlier
    259   // than |input_1|.
    260   input_timestamp_helper_.SetBaseTimestamp(base::TimeDelta::FromSeconds(0));
    261   scoped_refptr<AudioBuffer> input_2 = GetNextInputBuffer(0.1f);
    262 
    263   EXPECT_GT(input_1->timestamp(), input_2->timestamp());
    264   EXPECT_TRUE(splicer_.AddInput(input_1));
    265   EXPECT_FALSE(splicer_.AddInput(input_2));
    266 }
    267 
    268 
    269 // Test when one buffer partially overlaps another.
    270 // +--------------+
    271 // |11111111111111|
    272 // +--------------+
    273 //            +--------------+
    274 //            |22222222222222|
    275 //            +--------------+
    276 // Results in:
    277 // +--------------+----------+
    278 // |11111111111111|2222222222|
    279 // +--------------+----------+
    280 TEST_F(AudioSplicerTest, PartialOverlap) {
    281   scoped_refptr<AudioBuffer> input_1 = GetNextInputBuffer(0.1f);
    282 
    283   // Reset timestamp helper so that the next buffer will have a
    284   // timestamp that starts in the middle of |input_1|.
    285   const int kOverlapSize = input_1->frame_count() / 4;
    286   input_timestamp_helper_.SetBaseTimestamp(input_1->timestamp());
    287   input_timestamp_helper_.AddFrames(input_1->frame_count() - kOverlapSize);
    288 
    289   scoped_refptr<AudioBuffer> input_2 = GetNextInputBuffer(0.2f);
    290 
    291   EXPECT_TRUE(splicer_.AddInput(input_1));
    292   EXPECT_TRUE(splicer_.AddInput(input_2));
    293 
    294   EXPECT_TRUE(splicer_.HasNextBuffer());
    295   scoped_refptr<AudioBuffer> output_1 = splicer_.GetNextBuffer();
    296   scoped_refptr<AudioBuffer> output_2 = splicer_.GetNextBuffer();
    297   EXPECT_FALSE(splicer_.HasNextBuffer());
    298 
    299   // Verify that the first input buffer passed through unmodified.
    300   EXPECT_EQ(input_1->timestamp(), output_1->timestamp());
    301   EXPECT_EQ(input_1->duration(), output_1->duration());
    302   EXPECT_EQ(input_1->frame_count(), output_1->frame_count());
    303   EXPECT_TRUE(VerifyData(output_1, 0.1f));
    304 
    305   // Verify that the second input buffer was truncated to only contain
    306   // the samples that are after the end of |input_1|. Note that data is not
    307   // copied, so |input_2|'s values are modified.
    308   base::TimeDelta expected_timestamp =
    309       input_1->timestamp() + input_1->duration();
    310   base::TimeDelta expected_duration =
    311       (input_2->timestamp() + input_2->duration()) - expected_timestamp;
    312   EXPECT_EQ(expected_timestamp, output_2->timestamp());
    313   EXPECT_EQ(expected_duration, output_2->duration());
    314   EXPECT_TRUE(VerifyData(output_2, 0.2f));
    315 }
    316 
    317 
    318 // Test that an input buffer that is completely overlapped by a buffer
    319 // that was already added is dropped.
    320 // +--------------+
    321 // |11111111111111|
    322 // +--------------+
    323 //       +-----+
    324 //       |22222|
    325 //       +-----+
    326 //                +-------------+
    327 //                |3333333333333|
    328 //                +-------------+
    329 // Results in:
    330 // +--------------+-------------+
    331 // |11111111111111|3333333333333|
    332 // +--------------+-------------+
    333 TEST_F(AudioSplicerTest, DropBuffer) {
    334   scoped_refptr<AudioBuffer> input_1 = GetNextInputBuffer(0.1f);
    335 
    336   // Reset timestamp helper so that the next buffer will have a
    337   // timestamp that starts in the middle of |input_1|.
    338   const int kOverlapOffset = input_1->frame_count() / 2;
    339   const int kOverlapSize = input_1->frame_count() / 4;
    340   input_timestamp_helper_.SetBaseTimestamp(input_1->timestamp());
    341   input_timestamp_helper_.AddFrames(kOverlapOffset);
    342 
    343   scoped_refptr<AudioBuffer> input_2 = GetNextInputBuffer(0.2f, kOverlapSize);
    344 
    345   // Reset the timestamp helper so the next buffer will be right after
    346   // |input_1|.
    347   input_timestamp_helper_.SetBaseTimestamp(input_1->timestamp());
    348   input_timestamp_helper_.AddFrames(input_1->frame_count());
    349   scoped_refptr<AudioBuffer> input_3 = GetNextInputBuffer(0.3f);
    350 
    351   EXPECT_TRUE(splicer_.AddInput(input_1));
    352   EXPECT_TRUE(splicer_.AddInput(input_2));
    353   EXPECT_TRUE(splicer_.AddInput(input_3));
    354 
    355   EXPECT_TRUE(splicer_.HasNextBuffer());
    356   scoped_refptr<AudioBuffer> output_1 = splicer_.GetNextBuffer();
    357   scoped_refptr<AudioBuffer> output_2 = splicer_.GetNextBuffer();
    358   EXPECT_FALSE(splicer_.HasNextBuffer());
    359 
    360   // Verify that the first input buffer passed through unmodified.
    361   EXPECT_EQ(input_1->timestamp(), output_1->timestamp());
    362   EXPECT_EQ(input_1->duration(), output_1->duration());
    363   EXPECT_EQ(input_1->frame_count(), output_1->frame_count());
    364   EXPECT_TRUE(VerifyData(output_1, 0.1f));
    365 
    366   // Verify that the second output buffer only contains
    367   // the samples that are in |input_3|.
    368   EXPECT_EQ(input_3->timestamp(), output_2->timestamp());
    369   EXPECT_EQ(input_3->duration(), output_2->duration());
    370   EXPECT_EQ(input_3->frame_count(), output_2->frame_count());
    371   EXPECT_TRUE(VerifyData(output_2, 0.3f));
    372 }
    373 
    374 }  // namespace media
    375