1 /*
2 * Copyright (C) 2017 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define LOG_TAG "BufferItemConsumer_test"
18 //#define LOG_NDEBUG 0
19
20 #include <gmock/gmock.h>
21 #include <gtest/gtest.h>
22 #include <gui/BufferItemConsumer.h>
23 #include <gui/IProducerListener.h>
24 #include <gui/Surface.h>
25 #include <ui/BufferQueueDefs.h>
26 #include <ui/GraphicBuffer.h>
27 #include <utils/Errors.h>
28
29 #include <unordered_set>
30
31 namespace android {
32
33 static constexpr int kWidth = 100;
34 static constexpr int kHeight = 100;
35 static constexpr int kMaxLockedBuffers = 3;
36 static constexpr int kFormat = HAL_PIXEL_FORMAT_RGBA_8888;
37 static constexpr int kUsage = GRALLOC_USAGE_SW_READ_RARELY;
38 static constexpr int kFrameSleepUs = 30 * 1000;
39
40 class BufferItemConsumerTest : public ::testing::Test {
41 protected:
42 struct BufferFreedListener
43 : public BufferItemConsumer::BufferFreedListener {
BufferFreedListenerandroid::BufferItemConsumerTest::BufferFreedListener44 explicit BufferFreedListener(BufferItemConsumerTest* test)
45 : mTest(test) {}
onBufferFreedandroid::BufferItemConsumerTest::BufferFreedListener46 void onBufferFreed(const wp<GraphicBuffer>& /* gBuffer */) override {
47 mTest->HandleBufferFreed();
48 }
49 BufferItemConsumerTest* mTest;
50 };
51
52 struct TrackingProducerListener : public BnProducerListener {
TrackingProducerListenerandroid::BufferItemConsumerTest::TrackingProducerListener53 TrackingProducerListener(BufferItemConsumerTest* test) : mTest(test) {}
54
onBufferReleasedandroid::BufferItemConsumerTest::TrackingProducerListener55 virtual void onBufferReleased() override {}
needsReleaseNotifyandroid::BufferItemConsumerTest::TrackingProducerListener56 virtual bool needsReleaseNotify() override { return true; }
onBuffersDiscardedandroid::BufferItemConsumerTest::TrackingProducerListener57 virtual void onBuffersDiscarded(const std::vector<int32_t>&) override {}
onBufferDetachedandroid::BufferItemConsumerTest::TrackingProducerListener58 virtual void onBufferDetached(int slot) override { mTest->HandleBufferDetached(slot); }
59
60 BufferItemConsumerTest* mTest;
61 };
62
SetUp()63 void SetUp() override {
64 mBuffers.resize(BufferQueueDefs::NUM_BUFFER_SLOTS);
65
66 sp<Surface> surface;
67 std::tie(mBIC, surface) = BufferItemConsumer::create(kUsage, kMaxLockedBuffers, true);
68 String8 name("BufferItemConsumer_Under_Test");
69 mBIC->setName(name);
70 mBFL = new BufferFreedListener(this);
71 mBIC->setBufferFreedListener(mBFL);
72
73 sp<IProducerListener> producerListener = new TrackingProducerListener(this);
74 mProducer = surface->getIGraphicBufferProducer();
75 IGraphicBufferProducer::QueueBufferOutput bufferOutput;
76 ASSERT_EQ(NO_ERROR,
77 mProducer->connect(producerListener, NATIVE_WINDOW_API_CPU,
78 true, &bufferOutput));
79 ASSERT_EQ(NO_ERROR,
80 mProducer->setMaxDequeuedBufferCount(kMaxLockedBuffers));
81 }
82
GetFreedBufferCount()83 int GetFreedBufferCount() {
84 std::lock_guard<std::mutex> lock(mMutex);
85 return mFreedBufferCount;
86 }
87
HandleBufferFreed()88 void HandleBufferFreed() {
89 std::lock_guard<std::mutex> lock(mMutex);
90 mFreedBufferCount++;
91 ALOGD("HandleBufferFreed, mFreedBufferCount=%d", mFreedBufferCount);
92 }
93
HandleBufferDetached(int slot)94 void HandleBufferDetached(int slot) {
95 std::lock_guard<std::mutex> lock(mMutex);
96 mDetachedBufferSlots.push_back(slot);
97 ALOGD("HandleBufferDetached, slot=%d mDetachedBufferSlots-count=%zu", slot,
98 mDetachedBufferSlots.size());
99 }
100
DequeueBuffer(int * outSlot)101 void DequeueBuffer(int* outSlot) {
102 ASSERT_NE(outSlot, nullptr);
103
104 int slot;
105 sp<Fence> outFence;
106 status_t ret = mProducer->dequeueBuffer(&slot, &outFence, kWidth, kHeight, 0, 0,
107 nullptr, nullptr);
108 ASSERT_GE(ret, 0);
109
110 ALOGD("dequeueBuffer: slot=%d", slot);
111 if (ret & IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION) {
112 ret = mProducer->requestBuffer(slot, &mBuffers[slot]);
113 ASSERT_EQ(NO_ERROR, ret);
114 }
115 *outSlot = slot;
116 }
117
QueueBuffer(int slot)118 void QueueBuffer(int slot) {
119 ALOGD("enqueueBuffer: slot=%d", slot);
120 IGraphicBufferProducer::QueueBufferInput bufferInput(
121 0ULL, true, HAL_DATASPACE_UNKNOWN, Rect::INVALID_RECT,
122 NATIVE_WINDOW_SCALING_MODE_FREEZE, 0, Fence::NO_FENCE);
123 IGraphicBufferProducer::QueueBufferOutput bufferOutput;
124 status_t ret = mProducer->queueBuffer(slot, bufferInput, &bufferOutput);
125 ASSERT_EQ(NO_ERROR, ret);
126 }
127
AcquireBuffer(int * outSlot)128 void AcquireBuffer(int* outSlot) {
129 ASSERT_NE(outSlot, nullptr);
130 BufferItem buffer;
131 status_t ret = mBIC->acquireBuffer(&buffer, 0, false);
132 ASSERT_EQ(NO_ERROR, ret);
133
134 ALOGD("acquireBuffer: slot=%d", buffer.mSlot);
135 *outSlot = buffer.mSlot;
136 }
137
ReleaseBuffer(int slot)138 void ReleaseBuffer(int slot) {
139 ALOGD("releaseBuffer: slot=%d", slot);
140 BufferItem buffer;
141 buffer.mSlot = slot;
142 buffer.mGraphicBuffer = mBuffers[slot];
143 status_t ret = mBIC->releaseBuffer(buffer, Fence::NO_FENCE);
144 ASSERT_EQ(NO_ERROR, ret);
145 }
146
DetachBuffer(int slot)147 void DetachBuffer(int slot) {
148 ALOGD("detachBuffer: slot=%d", slot);
149 status_t ret = mBIC->detachBuffer(mBuffers[slot]);
150 ASSERT_EQ(NO_ERROR, ret);
151 }
152
153 std::mutex mMutex;
154 int mFreedBufferCount{0};
155 std::vector<int> mDetachedBufferSlots = {};
156
157 sp<BufferItemConsumer> mBIC;
158 sp<BufferFreedListener> mBFL;
159 sp<IGraphicBufferProducer> mProducer;
160 sp<IGraphicBufferConsumer> mConsumer;
161 std::vector<sp<GraphicBuffer>> mBuffers;
162 };
163
164 // Test that detaching buffer from consumer side triggers onBufferFreed.
TEST_F(BufferItemConsumerTest,TriggerBufferFreed_DetachBufferFromConsumer)165 TEST_F(BufferItemConsumerTest, TriggerBufferFreed_DetachBufferFromConsumer) {
166 int slot;
167 // Producer: generate a placeholder buffer.
168 DequeueBuffer(&slot);
169 QueueBuffer(slot);
170
171 ASSERT_EQ(0, GetFreedBufferCount());
172 // Consumer: acquire the buffer and then detach it.
173 AcquireBuffer(&slot);
174 status_t ret = mBIC->detachBuffer(slot);
175 ASSERT_EQ(NO_ERROR, ret);
176
177 // Sleep to give some time for callbacks to happen.
178 usleep(kFrameSleepUs);
179 ASSERT_EQ(1, GetFreedBufferCount());
180 }
181
182 // Test that detaching buffer from producer side triggers onBufferFreed.
TEST_F(BufferItemConsumerTest,TriggerBufferFreed_DetachBufferFromProducer)183 TEST_F(BufferItemConsumerTest, TriggerBufferFreed_DetachBufferFromProducer) {
184 int slot;
185 // Let buffer go through the cycle at least once.
186 DequeueBuffer(&slot);
187 QueueBuffer(slot);
188 AcquireBuffer(&slot);
189 ReleaseBuffer(slot);
190
191 ASSERT_EQ(0, GetFreedBufferCount());
192
193 // Producer: generate the buffer again.
194 DequeueBuffer(&slot);
195
196 // Producer: detach the buffer.
197 status_t ret = mProducer->detachBuffer(slot);
198 ASSERT_EQ(NO_ERROR, ret);
199
200 // Sleep to give some time for callbacks to happen.
201 usleep(kFrameSleepUs);
202 ASSERT_EQ(1, GetFreedBufferCount());
203 }
204
205 // Test that abandoning BufferItemConsumer triggers onBufferFreed.
TEST_F(BufferItemConsumerTest,TriggerBufferFreed_AbandonBufferItemConsumer)206 TEST_F(BufferItemConsumerTest, TriggerBufferFreed_AbandonBufferItemConsumer) {
207 int slot;
208 // Let buffer go through the cycle at least once.
209 DequeueBuffer(&slot);
210 QueueBuffer(slot);
211 AcquireBuffer(&slot);
212 ReleaseBuffer(slot);
213
214 // Abandon the BufferItemConsumer.
215 mBIC->abandon();
216
217 // Sleep to give some time for callbacks to happen.
218 usleep(kFrameSleepUs);
219 ASSERT_EQ(1, GetFreedBufferCount());
220 }
221
222 // Test that delete BufferItemConsumer triggers onBufferFreed.
TEST_F(BufferItemConsumerTest,TriggerBufferFreed_DeleteBufferItemConsumer)223 TEST_F(BufferItemConsumerTest, TriggerBufferFreed_DeleteBufferItemConsumer) {
224 int slot;
225 // Let buffer go through the cycle at least once.
226 DequeueBuffer(&slot);
227 QueueBuffer(slot);
228 AcquireBuffer(&slot);
229 ReleaseBuffer(slot);
230
231 // Delete the BufferItemConsumer.
232 mBIC.clear();
233
234 // Sleep to give some time for callbacks to happen.
235 usleep(kFrameSleepUs);
236 ASSERT_EQ(1, GetFreedBufferCount());
237 }
238
TEST_F(BufferItemConsumerTest,ResizeAcquireCount)239 TEST_F(BufferItemConsumerTest, ResizeAcquireCount) {
240 EXPECT_EQ(OK, mBIC->setMaxAcquiredBufferCount(kMaxLockedBuffers + 1));
241 EXPECT_EQ(OK, mBIC->setMaxAcquiredBufferCount(kMaxLockedBuffers + 2));
242 EXPECT_EQ(OK, mBIC->setMaxAcquiredBufferCount(kMaxLockedBuffers - 1));
243 EXPECT_EQ(OK, mBIC->setMaxAcquiredBufferCount(kMaxLockedBuffers - 2));
244 EXPECT_EQ(OK, mBIC->setMaxAcquiredBufferCount(kMaxLockedBuffers + 1));
245 EXPECT_EQ(OK, mBIC->setMaxAcquiredBufferCount(kMaxLockedBuffers - 1));
246 }
247
TEST_F(BufferItemConsumerTest,AttachBuffer)248 TEST_F(BufferItemConsumerTest, AttachBuffer) {
249 ASSERT_EQ(OK, mBIC->setMaxAcquiredBufferCount(1));
250
251 int slot;
252 DequeueBuffer(&slot);
253 QueueBuffer(slot);
254 AcquireBuffer(&slot);
255
256 sp<GraphicBuffer> newBuffer1 = sp<GraphicBuffer>::make(kWidth, kHeight, kFormat, kUsage);
257 sp<GraphicBuffer> newBuffer2 = sp<GraphicBuffer>::make(kWidth, kHeight, kFormat, kUsage);
258
259 // For some reason, you can attach an extra buffer?
260 // b/400973991 to investigate
261 EXPECT_EQ(OK, mBIC->attachBuffer(newBuffer1));
262 EXPECT_EQ(INVALID_OPERATION, mBIC->attachBuffer(newBuffer2));
263
264 ReleaseBuffer(slot);
265
266 EXPECT_EQ(OK, mBIC->attachBuffer(newBuffer2));
267 EXPECT_EQ(OK, mBIC->releaseBuffer(newBuffer1, Fence::NO_FENCE));
268 EXPECT_EQ(OK, mBIC->releaseBuffer(newBuffer2, Fence::NO_FENCE));
269 }
270
271 #if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_PLATFORM_API_IMPROVEMENTS)
272 // Test that delete BufferItemConsumer triggers onBufferFreed.
TEST_F(BufferItemConsumerTest,DetachBufferWithBuffer)273 TEST_F(BufferItemConsumerTest, DetachBufferWithBuffer) {
274 int slot;
275 // Let buffer go through the cycle at least once.
276 DequeueBuffer(&slot);
277 QueueBuffer(slot);
278 AcquireBuffer(&slot);
279
280 sp<GraphicBuffer> buffer = mBuffers[slot];
281 EXPECT_EQ(OK, mBIC->detachBuffer(buffer));
282 EXPECT_THAT(mDetachedBufferSlots, testing::ElementsAre(slot));
283 }
284 #endif // COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_PLATFORM_API_IMPROVEMENTS)
285
286 #if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_UNLIMITED_SLOTS)
TEST_F(BufferItemConsumerTest,UnlimitedSlots_AcquireReleaseAll)287 TEST_F(BufferItemConsumerTest, UnlimitedSlots_AcquireReleaseAll) {
288 ASSERT_EQ(OK, mProducer->extendSlotCount(256));
289 mBuffers.resize(256);
290
291 ASSERT_EQ(OK, mProducer->setMaxDequeuedBufferCount(100));
292
293 std::unordered_set<int> slots;
294 for (int i = 0; i < 100; i++) {
295 int slot;
296 DequeueBuffer(&slot);
297 slots.insert(slot);
298 }
299 EXPECT_EQ(100u, slots.size());
300
301 for (int dequeuedSlot : slots) {
302 QueueBuffer(dequeuedSlot);
303
304 int slot;
305 AcquireBuffer(&slot);
306 ReleaseBuffer(slot);
307 }
308 }
309
TEST_F(BufferItemConsumerTest,UnlimitedSlots_AcquireDetachAll)310 TEST_F(BufferItemConsumerTest, UnlimitedSlots_AcquireDetachAll) {
311 ASSERT_EQ(OK, mProducer->extendSlotCount(256));
312 mBuffers.resize(256);
313
314 ASSERT_EQ(OK, mProducer->setMaxDequeuedBufferCount(100));
315
316 std::unordered_set<int> slots;
317 for (int i = 0; i < 100; i++) {
318 int slot;
319 DequeueBuffer(&slot);
320 slots.insert(slot);
321 }
322 EXPECT_EQ(100u, slots.size());
323
324 for (int dequeuedSlot : slots) {
325 QueueBuffer(dequeuedSlot);
326
327 int slot;
328 AcquireBuffer(&slot);
329 DetachBuffer(slot);
330 }
331 }
332 #endif
333
334 } // namespace android
335