frame_buffer_pool_unittest.cc 3.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116
  1. // Copyright 2017 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. #include "media/filters/frame_buffer_pool.h"
  5. #include "base/test/simple_test_tick_clock.h"
  6. #include "base/test/test_message_loop.h"
  7. #include "testing/gtest/include/gtest/gtest.h"
  8. namespace media {
  9. constexpr size_t kBufferSize = 1024;
  10. TEST(FrameBufferPool, BasicFunctionality) {
  11. base::TestMessageLoop message_loop;
  12. scoped_refptr<FrameBufferPool> pool = new FrameBufferPool();
  13. void* priv1 = nullptr;
  14. uint8_t* buf1 = pool->GetFrameBuffer(kBufferSize, &priv1);
  15. ASSERT_TRUE(priv1);
  16. ASSERT_TRUE(buf1);
  17. memset(buf1, 0, kBufferSize);
  18. void* priv2 = nullptr;
  19. uint8_t* buf2 = pool->GetFrameBuffer(kBufferSize, &priv2);
  20. ASSERT_TRUE(priv2);
  21. ASSERT_TRUE(buf2);
  22. EXPECT_NE(priv1, priv2);
  23. EXPECT_NE(buf1, buf2);
  24. memset(buf2, 0, kBufferSize);
  25. uint8_t* alpha = pool->AllocateAlphaPlaneForFrameBuffer(kBufferSize, priv1);
  26. ASSERT_TRUE(alpha);
  27. EXPECT_NE(alpha, buf1);
  28. EXPECT_NE(alpha, buf2);
  29. memset(alpha, 0, kBufferSize);
  30. EXPECT_EQ(2u, pool->get_pool_size_for_testing());
  31. // Frames are not released immediately, so this should still show two frames.
  32. pool->ReleaseFrameBuffer(priv2);
  33. priv2 = buf2 = nullptr;
  34. EXPECT_EQ(2u, pool->get_pool_size_for_testing());
  35. auto frame_release_cb = pool->CreateFrameCallback(priv1);
  36. // Shutdown should release all memory that's not held by VideoFrames.
  37. pool->Shutdown();
  38. EXPECT_EQ(1u, pool->get_pool_size_for_testing());
  39. memset(buf1, 0, kBufferSize);
  40. memset(alpha, 0, kBufferSize);
  41. // This will release all memory since we're in the shutdown state.
  42. std::move(frame_release_cb).Run();
  43. EXPECT_EQ(0u, pool->get_pool_size_for_testing());
  44. }
  45. TEST(FrameBufferPool, ForceAllocationError) {
  46. base::TestMessageLoop message_loop;
  47. scoped_refptr<FrameBufferPool> pool = new FrameBufferPool();
  48. pool->force_allocation_error_for_testing();
  49. void* priv1 = nullptr;
  50. uint8_t* buf1 = pool->GetFrameBuffer(kBufferSize, &priv1);
  51. ASSERT_FALSE(priv1);
  52. ASSERT_FALSE(buf1);
  53. pool->Shutdown();
  54. }
  55. TEST(FrameBufferPool, DeferredDestruction) {
  56. base::TestMessageLoop message_loop;
  57. scoped_refptr<FrameBufferPool> pool = new FrameBufferPool();
  58. base::SimpleTestTickClock test_clock;
  59. pool->set_tick_clock_for_testing(&test_clock);
  60. void* priv1 = nullptr;
  61. uint8_t* buf1 = pool->GetFrameBuffer(kBufferSize, &priv1);
  62. void* priv2 = nullptr;
  63. uint8_t* buf2 = pool->GetFrameBuffer(kBufferSize, &priv2);
  64. void* priv3 = nullptr;
  65. uint8_t* buf3 = pool->GetFrameBuffer(kBufferSize, &priv3);
  66. EXPECT_EQ(3u, pool->get_pool_size_for_testing());
  67. auto frame_release_cb = pool->CreateFrameCallback(priv1);
  68. pool->ReleaseFrameBuffer(priv1);
  69. priv1 = buf1 = nullptr;
  70. std::move(frame_release_cb).Run();
  71. // Frame buffers should not be immediately deleted upon return.
  72. EXPECT_EQ(3u, pool->get_pool_size_for_testing());
  73. // Advance some time, but not enough to trigger expiration.
  74. test_clock.Advance(base::Seconds(FrameBufferPool::kStaleFrameLimitSecs / 2));
  75. // We should still have 3 frame buffers in the pool at this point.
  76. frame_release_cb = pool->CreateFrameCallback(priv2);
  77. pool->ReleaseFrameBuffer(priv2);
  78. priv2 = buf2 = nullptr;
  79. std::move(frame_release_cb).Run();
  80. EXPECT_EQ(3u, pool->get_pool_size_for_testing());
  81. test_clock.Advance(base::Seconds(FrameBufferPool::kStaleFrameLimitSecs + 1));
  82. // All but this most recently released frame should remain now.
  83. frame_release_cb = pool->CreateFrameCallback(priv3);
  84. pool->ReleaseFrameBuffer(priv3);
  85. priv3 = buf3 = nullptr;
  86. std::move(frame_release_cb).Run();
  87. EXPECT_EQ(1u, pool->get_pool_size_for_testing());
  88. pool->Shutdown();
  89. }
  90. } // namespace media