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: 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 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 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 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 { 70 virtual void onFrameAvailable() {} 71 virtual void onBuffersReleased() {} 72 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 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 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 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 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 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 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 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
