1 /*
2  * Copyright (C) 2012 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 "BufferQueue_test"
18 //#define LOG_NDEBUG 0
19 
20 #include <gui/BufferQueue.h>
21 #include <gui/IProducerListener.h>
22 
23 #include <ui/GraphicBuffer.h>
24 
25 #include <binder/IPCThreadState.h>
26 #include <binder/IServiceManager.h>
27 #include <binder/ProcessState.h>
28 
29 #include <utils/String8.h>
30 #include <utils/threads.h>
31 
32 #include <gtest/gtest.h>
33 
34 namespace android {
35 
36 class BufferQueueTest : public ::testing::Test {
37 
38 public:
39 protected:
BufferQueueTest()40     BufferQueueTest() {
41         const ::testing::TestInfo* const testInfo =
42             ::testing::UnitTest::GetInstance()->current_test_info();
43         ALOGV("Begin test: %s.%s", testInfo->test_case_name(),
44                 testInfo->name());
45     }
46 
~BufferQueueTest()47     ~BufferQueueTest() {
48         const ::testing::TestInfo* const testInfo =
49             ::testing::UnitTest::GetInstance()->current_test_info();
50         ALOGV("End test:   %s.%s", testInfo->test_case_name(),
51                 testInfo->name());
52     }
53 
GetMinUndequeuedBufferCount(int * bufferCount)54     void GetMinUndequeuedBufferCount(int* bufferCount) {
55         ASSERT_TRUE(bufferCount != NULL);
56         ASSERT_EQ(OK, mProducer->query(NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS,
57                     bufferCount));
58         ASSERT_GE(*bufferCount, 0);
59     }
60 
createBufferQueue()61     void createBufferQueue() {
62         BufferQueue::createBufferQueue(&mProducer, &mConsumer);
63     }
64 
65     sp<IGraphicBufferProducer> mProducer;
66     sp<IGraphicBufferConsumer> mConsumer;
67 };
68 
69 struct DummyConsumer : public BnConsumerListener {
onFrameAvailableandroid::DummyConsumer70     virtual void onFrameAvailable(const BufferItem& /* item */) {}
onBuffersReleasedandroid::DummyConsumer71     virtual void onBuffersReleased() {}
onSidebandStreamChangedandroid::DummyConsumer72     virtual void onSidebandStreamChanged() {}
73 };
74 
75 // XXX: Tests that fork a process to hold the BufferQueue must run before tests
76 // that use a local BufferQueue, or else Binder will get unhappy
TEST_F(BufferQueueTest,BufferQueueInAnotherProcess)77 TEST_F(BufferQueueTest, BufferQueueInAnotherProcess) {
78     const String16 PRODUCER_NAME = String16("BQTestProducer");
79     const String16 CONSUMER_NAME = String16("BQTestConsumer");
80 
81     pid_t forkPid = fork();
82     ASSERT_NE(forkPid, -1);
83 
84     if (forkPid == 0) {
85         // Child process
86         sp<IGraphicBufferProducer> producer;
87         sp<IGraphicBufferConsumer> consumer;
88         BufferQueue::createBufferQueue(&producer, &consumer);
89         sp<IServiceManager> serviceManager = defaultServiceManager();
90         serviceManager->addService(PRODUCER_NAME, producer->asBinder());
91         serviceManager->addService(CONSUMER_NAME, consumer->asBinder());
92         ProcessState::self()->startThreadPool();
93         IPCThreadState::self()->joinThreadPool();
94         LOG_ALWAYS_FATAL("Shouldn't be here");
95     }
96 
97     sp<IServiceManager> serviceManager = defaultServiceManager();
98     sp<IBinder> binderProducer =
99         serviceManager->getService(PRODUCER_NAME);
100     mProducer = interface_cast<IGraphicBufferProducer>(binderProducer);
101     EXPECT_TRUE(mProducer != NULL);
102     sp<IBinder> binderConsumer =
103         serviceManager->getService(CONSUMER_NAME);
104     mConsumer = interface_cast<IGraphicBufferConsumer>(binderConsumer);
105     EXPECT_TRUE(mConsumer != NULL);
106 
107     sp<DummyConsumer> dc(new DummyConsumer);
108     ASSERT_EQ(OK, mConsumer->consumerConnect(dc, false));
109     IGraphicBufferProducer::QueueBufferOutput output;
110     ASSERT_EQ(OK,
111             mProducer->connect(NULL, NATIVE_WINDOW_API_CPU, false, &output));
112 
113     int slot;
114     sp<Fence> fence;
115     sp<GraphicBuffer> buffer;
116     ASSERT_EQ(IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION,
117             mProducer->dequeueBuffer(&slot, &fence, false, 0, 0, 0,
118                     GRALLOC_USAGE_SW_WRITE_OFTEN));
119     ASSERT_EQ(OK, mProducer->requestBuffer(slot, &buffer));
120 
121     uint32_t* dataIn;
122     ASSERT_EQ(OK, buffer->lock(GraphicBuffer::USAGE_SW_WRITE_OFTEN,
123             reinterpret_cast<void**>(&dataIn)));
124     *dataIn = 0x12345678;
125     ASSERT_EQ(OK, buffer->unlock());
126 
127     IGraphicBufferProducer::QueueBufferInput input(0, false, Rect(0, 0, 1, 1),
128             NATIVE_WINDOW_SCALING_MODE_FREEZE, 0, false, Fence::NO_FENCE);
129     ASSERT_EQ(OK, mProducer->queueBuffer(slot, input, &output));
130 
131     IGraphicBufferConsumer::BufferItem item;
132     ASSERT_EQ(OK, mConsumer->acquireBuffer(&item, 0));
133 
134     uint32_t* dataOut;
135     ASSERT_EQ(OK, item.mGraphicBuffer->lock(GraphicBuffer::USAGE_SW_READ_OFTEN,
136             reinterpret_cast<void**>(&dataOut)));
137     ASSERT_EQ(*dataOut, 0x12345678);
138     ASSERT_EQ(OK, item.mGraphicBuffer->unlock());
139 }
140 
TEST_F(BufferQueueTest,AcquireBuffer_ExceedsMaxAcquireCount_Fails)141 TEST_F(BufferQueueTest, AcquireBuffer_ExceedsMaxAcquireCount_Fails) {
142     createBufferQueue();
143     sp<DummyConsumer> dc(new DummyConsumer);
144     mConsumer->consumerConnect(dc, false);
145     IGraphicBufferProducer::QueueBufferOutput qbo;
146     mProducer->connect(new DummyProducerListener, NATIVE_WINDOW_API_CPU, false,
147             &qbo);
148     mProducer->setBufferCount(4);
149 
150     int slot;
151     sp<Fence> fence;
152     sp<GraphicBuffer> buf;
153     IGraphicBufferProducer::QueueBufferInput qbi(0, false, Rect(0, 0, 1, 1),
154             NATIVE_WINDOW_SCALING_MODE_FREEZE, 0, false, Fence::NO_FENCE);
155     BufferQueue::BufferItem item;
156 
157     for (int i = 0; i < 2; i++) {
158         ASSERT_EQ(IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION,
159                 mProducer->dequeueBuffer(&slot, &fence, false, 1, 1, 0,
160                     GRALLOC_USAGE_SW_READ_OFTEN));
161         ASSERT_EQ(OK, mProducer->requestBuffer(slot, &buf));
162         ASSERT_EQ(OK, mProducer->queueBuffer(slot, qbi, &qbo));
163         ASSERT_EQ(OK, mConsumer->acquireBuffer(&item, 0));
164     }
165 
166     ASSERT_EQ(IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION,
167             mProducer->dequeueBuffer(&slot, &fence, false, 1, 1, 0,
168                 GRALLOC_USAGE_SW_READ_OFTEN));
169     ASSERT_EQ(OK, mProducer->requestBuffer(slot, &buf));
170     ASSERT_EQ(OK, mProducer->queueBuffer(slot, qbi, &qbo));
171 
172     // Acquire the third buffer, which should fail.
173     ASSERT_EQ(INVALID_OPERATION, mConsumer->acquireBuffer(&item, 0));
174 }
175 
TEST_F(BufferQueueTest,SetMaxAcquiredBufferCountWithIllegalValues_ReturnsError)176 TEST_F(BufferQueueTest, SetMaxAcquiredBufferCountWithIllegalValues_ReturnsError) {
177     createBufferQueue();
178     sp<DummyConsumer> dc(new DummyConsumer);
179     mConsumer->consumerConnect(dc, false);
180 
181     int minBufferCount;
182     ASSERT_NO_FATAL_FAILURE(GetMinUndequeuedBufferCount(&minBufferCount));
183     EXPECT_EQ(BAD_VALUE, mConsumer->setMaxAcquiredBufferCount(
184                 minBufferCount - 1));
185 
186     EXPECT_EQ(BAD_VALUE, mConsumer->setMaxAcquiredBufferCount(0));
187     EXPECT_EQ(BAD_VALUE, mConsumer->setMaxAcquiredBufferCount(-3));
188     EXPECT_EQ(BAD_VALUE, mConsumer->setMaxAcquiredBufferCount(
189             BufferQueue::MAX_MAX_ACQUIRED_BUFFERS+1));
190     EXPECT_EQ(BAD_VALUE, mConsumer->setMaxAcquiredBufferCount(100));
191 }
192 
TEST_F(BufferQueueTest,SetMaxAcquiredBufferCountWithLegalValues_Succeeds)193 TEST_F(BufferQueueTest, SetMaxAcquiredBufferCountWithLegalValues_Succeeds) {
194     createBufferQueue();
195     sp<DummyConsumer> dc(new DummyConsumer);
196     mConsumer->consumerConnect(dc, false);
197 
198     int minBufferCount;
199     ASSERT_NO_FATAL_FAILURE(GetMinUndequeuedBufferCount(&minBufferCount));
200 
201     EXPECT_EQ(OK, mConsumer->setMaxAcquiredBufferCount(1));
202     EXPECT_EQ(OK, mConsumer->setMaxAcquiredBufferCount(2));
203     EXPECT_EQ(OK, mConsumer->setMaxAcquiredBufferCount(minBufferCount));
204     EXPECT_EQ(OK, mConsumer->setMaxAcquiredBufferCount(
205             BufferQueue::MAX_MAX_ACQUIRED_BUFFERS));
206 }
207 
TEST_F(BufferQueueTest,DetachAndReattachOnProducerSide)208 TEST_F(BufferQueueTest, DetachAndReattachOnProducerSide) {
209     createBufferQueue();
210     sp<DummyConsumer> dc(new DummyConsumer);
211     ASSERT_EQ(OK, mConsumer->consumerConnect(dc, false));
212     IGraphicBufferProducer::QueueBufferOutput output;
213     ASSERT_EQ(OK, mProducer->connect(new DummyProducerListener,
214             NATIVE_WINDOW_API_CPU, false, &output));
215 
216     ASSERT_EQ(BAD_VALUE, mProducer->detachBuffer(-1)); // Index too low
217     ASSERT_EQ(BAD_VALUE, mProducer->detachBuffer(
218                 BufferQueueDefs::NUM_BUFFER_SLOTS)); // Index too high
219     ASSERT_EQ(BAD_VALUE, mProducer->detachBuffer(0)); // Not dequeued
220 
221     int slot;
222     sp<Fence> fence;
223     sp<GraphicBuffer> buffer;
224     ASSERT_EQ(IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION,
225             mProducer->dequeueBuffer(&slot, &fence, false, 0, 0, 0,
226                     GRALLOC_USAGE_SW_WRITE_OFTEN));
227     ASSERT_EQ(BAD_VALUE, mProducer->detachBuffer(slot)); // Not requested
228     ASSERT_EQ(OK, mProducer->requestBuffer(slot, &buffer));
229     ASSERT_EQ(OK, mProducer->detachBuffer(slot));
230     ASSERT_EQ(BAD_VALUE, mProducer->detachBuffer(slot)); // Not dequeued
231 
232     sp<GraphicBuffer> safeToClobberBuffer;
233     // Can no longer request buffer from this slot
234     ASSERT_EQ(BAD_VALUE, mProducer->requestBuffer(slot, &safeToClobberBuffer));
235 
236     uint32_t* dataIn;
237     ASSERT_EQ(OK, buffer->lock(GraphicBuffer::USAGE_SW_WRITE_OFTEN,
238             reinterpret_cast<void**>(&dataIn)));
239     *dataIn = 0x12345678;
240     ASSERT_EQ(OK, buffer->unlock());
241 
242     int newSlot;
243     ASSERT_EQ(BAD_VALUE, mProducer->attachBuffer(NULL, safeToClobberBuffer));
244     ASSERT_EQ(BAD_VALUE, mProducer->attachBuffer(&newSlot, NULL));
245 
246     ASSERT_EQ(OK, mProducer->attachBuffer(&newSlot, buffer));
247     IGraphicBufferProducer::QueueBufferInput input(0, false, Rect(0, 0, 1, 1),
248             NATIVE_WINDOW_SCALING_MODE_FREEZE, 0, false, Fence::NO_FENCE);
249     ASSERT_EQ(OK, mProducer->queueBuffer(newSlot, input, &output));
250 
251     IGraphicBufferConsumer::BufferItem item;
252     ASSERT_EQ(OK, mConsumer->acquireBuffer(&item, static_cast<nsecs_t>(0)));
253 
254     uint32_t* dataOut;
255     ASSERT_EQ(OK, item.mGraphicBuffer->lock(GraphicBuffer::USAGE_SW_READ_OFTEN,
256             reinterpret_cast<void**>(&dataOut)));
257     ASSERT_EQ(*dataOut, 0x12345678);
258     ASSERT_EQ(OK, item.mGraphicBuffer->unlock());
259 }
260 
TEST_F(BufferQueueTest,DetachAndReattachOnConsumerSide)261 TEST_F(BufferQueueTest, DetachAndReattachOnConsumerSide) {
262     createBufferQueue();
263     sp<DummyConsumer> dc(new DummyConsumer);
264     ASSERT_EQ(OK, mConsumer->consumerConnect(dc, false));
265     IGraphicBufferProducer::QueueBufferOutput output;
266     ASSERT_EQ(OK, mProducer->connect(new DummyProducerListener,
267             NATIVE_WINDOW_API_CPU, false, &output));
268 
269     int slot;
270     sp<Fence> fence;
271     sp<GraphicBuffer> buffer;
272     ASSERT_EQ(IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION,
273             mProducer->dequeueBuffer(&slot, &fence, false, 0, 0, 0,
274                     GRALLOC_USAGE_SW_WRITE_OFTEN));
275     ASSERT_EQ(OK, mProducer->requestBuffer(slot, &buffer));
276     IGraphicBufferProducer::QueueBufferInput input(0, false, Rect(0, 0, 1, 1),
277             NATIVE_WINDOW_SCALING_MODE_FREEZE, 0, false, Fence::NO_FENCE);
278     ASSERT_EQ(OK, mProducer->queueBuffer(slot, input, &output));
279 
280     ASSERT_EQ(BAD_VALUE, mConsumer->detachBuffer(-1)); // Index too low
281     ASSERT_EQ(BAD_VALUE, mConsumer->detachBuffer(
282             BufferQueueDefs::NUM_BUFFER_SLOTS)); // Index too high
283     ASSERT_EQ(BAD_VALUE, mConsumer->detachBuffer(0)); // Not acquired
284 
285     IGraphicBufferConsumer::BufferItem item;
286     ASSERT_EQ(OK, mConsumer->acquireBuffer(&item, static_cast<nsecs_t>(0)));
287 
288     ASSERT_EQ(OK, mConsumer->detachBuffer(item.mBuf));
289     ASSERT_EQ(BAD_VALUE, mConsumer->detachBuffer(item.mBuf)); // Not acquired
290 
291     uint32_t* dataIn;
292     ASSERT_EQ(OK, item.mGraphicBuffer->lock(
293             GraphicBuffer::USAGE_SW_WRITE_OFTEN,
294             reinterpret_cast<void**>(&dataIn)));
295     *dataIn = 0x12345678;
296     ASSERT_EQ(OK, item.mGraphicBuffer->unlock());
297 
298     int newSlot;
299     sp<GraphicBuffer> safeToClobberBuffer;
300     ASSERT_EQ(BAD_VALUE, mConsumer->attachBuffer(NULL, safeToClobberBuffer));
301     ASSERT_EQ(BAD_VALUE, mConsumer->attachBuffer(&newSlot, NULL));
302     ASSERT_EQ(OK, mConsumer->attachBuffer(&newSlot, item.mGraphicBuffer));
303 
304     ASSERT_EQ(OK, mConsumer->releaseBuffer(newSlot, 0, EGL_NO_DISPLAY,
305             EGL_NO_SYNC_KHR, Fence::NO_FENCE));
306 
307     ASSERT_EQ(IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION,
308             mProducer->dequeueBuffer(&slot, &fence, false, 0, 0, 0,
309                     GRALLOC_USAGE_SW_WRITE_OFTEN));
310     ASSERT_EQ(OK, mProducer->requestBuffer(slot, &buffer));
311 
312     uint32_t* dataOut;
313     ASSERT_EQ(OK, buffer->lock(GraphicBuffer::USAGE_SW_READ_OFTEN,
314             reinterpret_cast<void**>(&dataOut)));
315     ASSERT_EQ(*dataOut, 0x12345678);
316     ASSERT_EQ(OK, buffer->unlock());
317 }
318 
TEST_F(BufferQueueTest,MoveFromConsumerToProducer)319 TEST_F(BufferQueueTest, MoveFromConsumerToProducer) {
320     createBufferQueue();
321     sp<DummyConsumer> dc(new DummyConsumer);
322     ASSERT_EQ(OK, mConsumer->consumerConnect(dc, false));
323     IGraphicBufferProducer::QueueBufferOutput output;
324     ASSERT_EQ(OK, mProducer->connect(new DummyProducerListener,
325             NATIVE_WINDOW_API_CPU, false, &output));
326 
327     int slot;
328     sp<Fence> fence;
329     sp<GraphicBuffer> buffer;
330     ASSERT_EQ(IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION,
331             mProducer->dequeueBuffer(&slot, &fence, false, 0, 0, 0,
332                     GRALLOC_USAGE_SW_WRITE_OFTEN));
333     ASSERT_EQ(OK, mProducer->requestBuffer(slot, &buffer));
334 
335     uint32_t* dataIn;
336     ASSERT_EQ(OK, buffer->lock(GraphicBuffer::USAGE_SW_WRITE_OFTEN,
337             reinterpret_cast<void**>(&dataIn)));
338     *dataIn = 0x12345678;
339     ASSERT_EQ(OK, buffer->unlock());
340 
341     IGraphicBufferProducer::QueueBufferInput input(0, false, Rect(0, 0, 1, 1),
342             NATIVE_WINDOW_SCALING_MODE_FREEZE, 0, false, Fence::NO_FENCE);
343     ASSERT_EQ(OK, mProducer->queueBuffer(slot, input, &output));
344 
345     IGraphicBufferConsumer::BufferItem item;
346     ASSERT_EQ(OK, mConsumer->acquireBuffer(&item, static_cast<nsecs_t>(0)));
347     ASSERT_EQ(OK, mConsumer->detachBuffer(item.mBuf));
348 
349     int newSlot;
350     ASSERT_EQ(OK, mProducer->attachBuffer(&newSlot, item.mGraphicBuffer));
351     ASSERT_EQ(OK, mProducer->queueBuffer(newSlot, input, &output));
352     ASSERT_EQ(OK, mConsumer->acquireBuffer(&item, static_cast<nsecs_t>(0)));
353 
354     uint32_t* dataOut;
355     ASSERT_EQ(OK, item.mGraphicBuffer->lock(GraphicBuffer::USAGE_SW_READ_OFTEN,
356             reinterpret_cast<void**>(&dataOut)));
357     ASSERT_EQ(*dataOut, 0x12345678);
358     ASSERT_EQ(OK, item.mGraphicBuffer->unlock());
359 }
360 
361 } // namespace android
362