content/browser/renderer_host/media/video_capture_buffer_pool_unittest.cc

   1 // Copyright (c) 2013 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 // Unit test for VideoCaptureBufferPool.
   6
   7 #include "content/browser/renderer_host/media/video_capture_buffer_pool.h"
   8
   9 #include "base/bind.h"
  10 #include "base/memory/ref_counted.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "content/browser/renderer_host/media/video_capture_controller.h"
  13 #include "media/base/video_frame.h"
  14 #include "media/base/video_util.h"
  15 #include "testing/gtest/include/gtest/gtest.h"
  16
  17 namespace content {
  18
  19 class VideoCaptureBufferPoolTest : public testing::Test {
  20  protected:
  21   class Buffer {
  22    public:
  23     Buffer(const scoped_refptr<VideoCaptureBufferPool> pool,
  24            int id,
  25            void* data,
  26            size_t size)
  27         : pool_(pool), id_(id), data_(data), size_(size) {}
  28     ~Buffer() { pool_->RelinquishProducerReservation(id()); }
  29     int id() const { return id_; }
  30     void* data() const { return data_; }
  31     size_t size() const { return size_; }
  32
  33    private:
  34     const scoped_refptr<VideoCaptureBufferPool> pool_;
  35     const int id_;
  36     void* const data_;
  37     const size_t size_;
  38   };
  39   VideoCaptureBufferPoolTest()
  40       : expected_dropped_id_(0),
  41         pool_(new VideoCaptureBufferPool(3)) {}
  42
  43   void ExpectDroppedId(int expected_dropped_id) {
  44     expected_dropped_id_ = expected_dropped_id;
  45   }
  46
  47   scoped_ptr<Buffer> ReserveI420Buffer(const gfx::Size& dimensions) {
  48     const size_t frame_bytes =
  49         media::VideoFrame::AllocationSize(media::VideoFrame::I420, dimensions);
  50     // To verify that ReserveI420Buffer always sets |buffer_id_to_drop|,
  51     // initialize it to something different than the expected value.
  52     int buffer_id_to_drop = ~expected_dropped_id_;
  53     int buffer_id = pool_->ReserveForProducer(frame_bytes, &buffer_id_to_drop);
  54     if (buffer_id == VideoCaptureBufferPool::kInvalidId)
  55       return scoped_ptr<Buffer>();
  56
  57     void* memory;
  58     size_t size;
  59     pool_->GetBufferInfo(buffer_id, &memory, &size);
  60     EXPECT_EQ(expected_dropped_id_, buffer_id_to_drop);
  61     return scoped_ptr<Buffer>(new Buffer(pool_, buffer_id, memory, size));
  62   }
  63
  64   int expected_dropped_id_;
  65   scoped_refptr<VideoCaptureBufferPool> pool_;
  66
  67  private:
  68   DISALLOW_COPY_AND_ASSIGN(VideoCaptureBufferPoolTest);
  69 };
  70
  71 TEST_F(VideoCaptureBufferPoolTest, BufferPool) {
  72   const gfx::Size size_lo = gfx::Size(640, 480);
  73   const gfx::Size size_hi = gfx::Size(1024, 768);
  74   scoped_refptr<media::VideoFrame> non_pool_frame =
  75       media::VideoFrame::CreateFrame(media::VideoFrame::YV12, size_lo,
  76                                      gfx::Rect(size_lo), size_lo,
  77                                      base::TimeDelta());
  78
  79   // Reallocation won't happen for the first part of the test.
  80   ExpectDroppedId(VideoCaptureBufferPool::kInvalidId);
  81
  82   scoped_ptr<Buffer> buffer1 = ReserveI420Buffer(size_lo);
  83   ASSERT_TRUE(NULL != buffer1.get());
  84   ASSERT_LE(media::VideoFrame::AllocationSize(media::VideoFrame::I420, size_lo),
  85             buffer1->size());
  86   scoped_ptr<Buffer> buffer2 = ReserveI420Buffer(size_lo);
  87   ASSERT_TRUE(NULL != buffer2.get());
  88   ASSERT_LE(media::VideoFrame::AllocationSize(media::VideoFrame::I420, size_lo),
  89             buffer2->size());
  90   scoped_ptr<Buffer> buffer3 = ReserveI420Buffer(size_lo);
  91   ASSERT_TRUE(NULL != buffer3.get());
  92   ASSERT_LE(media::VideoFrame::AllocationSize(media::VideoFrame::I420, size_lo),
  93             buffer3->size());
  94
  95   // Touch the memory.
  96   memset(buffer1->data(), 0x11, buffer1->size());
  97   memset(buffer2->data(), 0x44, buffer2->size());
  98   memset(buffer3->data(), 0x77, buffer3->size());
  99
 100   // Fourth buffer should fail.
 101   ASSERT_FALSE(ReserveI420Buffer(size_lo)) << "Pool should be empty";
 102
 103   // Release 1st buffer and retry; this should succeed.
 104   buffer1.reset();
 105   scoped_ptr<Buffer> buffer4 = ReserveI420Buffer(size_lo);
 106   ASSERT_TRUE(NULL != buffer4.get());
 107
 108   ASSERT_FALSE(ReserveI420Buffer(size_lo)) << "Pool should be empty";
 109   ASSERT_FALSE(ReserveI420Buffer(size_hi)) << "Pool should be empty";
 110
 111   // Validate the IDs
 112   int buffer_id2 = buffer2->id();
 113   ASSERT_EQ(1, buffer_id2);
 114   int buffer_id3 = buffer3->id();
 115   ASSERT_EQ(2, buffer_id3);
 116   void* const memory_pointer3 = buffer3->data();
 117   int buffer_id4 = buffer4->id();
 118   ASSERT_EQ(0, buffer_id4);
 119
 120   // Deliver a buffer.
 121   pool_->HoldForConsumers(buffer_id3, 2);
 122
 123   ASSERT_FALSE(ReserveI420Buffer(size_lo)) << "Pool should be empty";
 124
 125   buffer3.reset();  // Old producer releases buffer. Should be a noop.
 126   ASSERT_FALSE(ReserveI420Buffer(size_lo)) << "Pool should be empty";
 127   ASSERT_FALSE(ReserveI420Buffer(size_hi)) << "Pool should be empty";
 128
 129   buffer2.reset();  // Active producer releases buffer. Should free a buffer.
 130
 131   buffer1 = ReserveI420Buffer(size_lo);
 132   ASSERT_TRUE(NULL != buffer1.get());
 133   ASSERT_FALSE(ReserveI420Buffer(size_lo)) << "Pool should be empty";
 134
 135   // First consumer finishes.
 136   pool_->RelinquishConsumerHold(buffer_id3, 1);
 137   ASSERT_FALSE(ReserveI420Buffer(size_lo)) << "Pool should be empty";
 138
 139   // Second consumer finishes. This should free that buffer.
 140   pool_->RelinquishConsumerHold(buffer_id3, 1);
 141   buffer3 = ReserveI420Buffer(size_lo);
 142   ASSERT_TRUE(NULL != buffer3.get());
 143   ASSERT_EQ(buffer_id3, buffer3->id()) << "Buffer ID should be reused.";
 144   ASSERT_EQ(memory_pointer3, buffer3->data());
 145   ASSERT_FALSE(ReserveI420Buffer(size_lo)) << "Pool should be empty";
 146
 147   // Now deliver & consume buffer1, but don't release the buffer.
 148   int buffer_id1 = buffer1->id();
 149   ASSERT_EQ(1, buffer_id1);
 150   pool_->HoldForConsumers(buffer_id1, 5);
 151   pool_->RelinquishConsumerHold(buffer_id1, 5);
 152
 153   // Even though the consumer is done with the buffer at |buffer_id1|, it cannot
 154   // be re-allocated to the producer, because |buffer1| still references it. But
 155   // when |buffer1| goes away, we should be able to re-reserve the buffer (and
 156   // the ID ought to be the same).
 157   ASSERT_FALSE(ReserveI420Buffer(size_lo)) << "Pool should be empty";
 158   buffer1.reset();  // Should free the buffer.
 159   buffer2 = ReserveI420Buffer(size_lo);
 160   ASSERT_TRUE(NULL != buffer2.get());
 161   ASSERT_EQ(buffer_id1, buffer2->id());
 162   buffer_id2 = buffer_id1;
 163   ASSERT_FALSE(ReserveI420Buffer(size_lo)) << "Pool should be empty";
 164
 165   // Now try reallocation with different resolutions. We expect reallocation
 166   // to occur only when the old buffer is too small.
 167   buffer2.reset();
 168   ExpectDroppedId(buffer_id2);
 169   buffer2 = ReserveI420Buffer(size_hi);
 170   ASSERT_TRUE(NULL != buffer2.get());
 171   ASSERT_LE(media::VideoFrame::AllocationSize(media::VideoFrame::I420, size_hi),
 172             buffer2->size());
 173   ASSERT_EQ(3, buffer2->id());
 174   void* const memory_pointer_hi = buffer2->data();
 175   buffer2.reset();  // Frees it.
 176   ExpectDroppedId(VideoCaptureBufferPool::kInvalidId);
 177   buffer2 = ReserveI420Buffer(size_lo);
 178   void* const memory_pointer_lo = buffer2->data();
 179   ASSERT_EQ(memory_pointer_hi, memory_pointer_lo)
 180       << "Decrease in resolution should not reallocate buffer";
 181   ASSERT_TRUE(NULL != buffer2.get());
 182   ASSERT_EQ(3, buffer2->id());
 183   ASSERT_LE(media::VideoFrame::AllocationSize(media::VideoFrame::I420, size_lo),
 184             buffer2->size());
 185   ASSERT_FALSE(ReserveI420Buffer(size_lo)) << "Pool should be empty";
 186
 187   // Tear down the pool_, writing into the buffers. The buffer should preserve
 188   // the lifetime of the underlying memory.
 189   buffer3.reset();
 190   pool_ = NULL;
 191
 192   // Touch the memory.
 193   memset(buffer2->data(), 0x22, buffer2->size());
 194   memset(buffer4->data(), 0x55, buffer4->size());
 195
 196   buffer2.reset();
 197
 198   memset(buffer4->data(), 0x77, buffer4->size());
 199   buffer4.reset();
 200 }
 201
 202 } // namespace content