1 /* 2 * Copyright (C) 2011 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 #include "DummyConsumer.h" 18 19 #include <gtest/gtest.h> 20 21 #include <binder/IMemory.h> 22 #include <gui/ISurfaceComposer.h> 23 #include <gui/Surface.h> 24 #include <gui/SurfaceComposerClient.h> 25 #include <gui/BufferItemConsumer.h> 26 #include <ui/Rect.h> 27 #include <utils/String8.h> 28 29 #include <private/gui/ComposerService.h> 30 #include <binder/ProcessState.h> 31 32 namespace android { 33 34 class SurfaceTest : public ::testing::Test { 35 protected: 36 37 SurfaceTest() { 38 ProcessState::self()->startThreadPool(); 39 } 40 41 virtual void SetUp() { 42 mComposerClient = new SurfaceComposerClient; 43 ASSERT_EQ(NO_ERROR, mComposerClient->initCheck()); 44 45 mSurfaceControl = mComposerClient->createSurface( 46 String8("Test Surface"), 32, 32, PIXEL_FORMAT_RGBA_8888, 0); 47 48 ASSERT_TRUE(mSurfaceControl != NULL); 49 ASSERT_TRUE(mSurfaceControl->isValid()); 50 51 SurfaceComposerClient::openGlobalTransaction(); 52 ASSERT_EQ(NO_ERROR, mSurfaceControl->setLayer(0x7fffffff)); 53 ASSERT_EQ(NO_ERROR, mSurfaceControl->show()); 54 SurfaceComposerClient::closeGlobalTransaction(); 55 56 mSurface = mSurfaceControl->getSurface(); 57 ASSERT_TRUE(mSurface != NULL); 58 } 59 60 virtual void TearDown() { 61 mComposerClient->dispose(); 62 } 63 64 sp<Surface> mSurface; 65 sp<SurfaceComposerClient> mComposerClient; 66 sp<SurfaceControl> mSurfaceControl; 67 }; 68 69 TEST_F(SurfaceTest, QueuesToWindowComposerIsTrueWhenVisible) { 70 sp<ANativeWindow> anw(mSurface); 71 int result = -123; 72 int err = anw->query(anw.get(), NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER, 73 &result); 74 EXPECT_EQ(NO_ERROR, err); 75 EXPECT_EQ(1, result); 76 } 77 78 TEST_F(SurfaceTest, QueuesToWindowComposerIsTrueWhenPurgatorized) { 79 mSurfaceControl.clear(); 80 81 sp<ANativeWindow> anw(mSurface); 82 int result = -123; 83 int err = anw->query(anw.get(), NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER, 84 &result); 85 EXPECT_EQ(NO_ERROR, err); 86 EXPECT_EQ(1, result); 87 } 88 89 // This test probably doesn't belong here. 90 TEST_F(SurfaceTest, ScreenshotsOfProtectedBuffersSucceed) { 91 sp<ANativeWindow> anw(mSurface); 92 93 // Verify the screenshot works with no protected buffers. 94 sp<IGraphicBufferProducer> producer; 95 sp<IGraphicBufferConsumer> consumer; 96 BufferQueue::createBufferQueue(&producer, &consumer); 97 sp<CpuConsumer> cpuConsumer = new CpuConsumer(consumer, 1); 98 sp<ISurfaceComposer> sf(ComposerService::getComposerService()); 99 sp<IBinder> display(sf->getBuiltInDisplay(ISurfaceComposer::eDisplayIdMain)); 100 ASSERT_EQ(NO_ERROR, sf->captureScreen(display, producer, Rect(), 101 64, 64, 0, 0x7fffffff, false)); 102 103 ASSERT_EQ(NO_ERROR, native_window_api_connect(anw.get(), 104 NATIVE_WINDOW_API_CPU)); 105 // Set the PROTECTED usage bit and verify that the screenshot fails. Note 106 // that we need to dequeue a buffer in order for it to actually get 107 // allocated in SurfaceFlinger. 108 ASSERT_EQ(NO_ERROR, native_window_set_usage(anw.get(), 109 GRALLOC_USAGE_PROTECTED)); 110 ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(anw.get(), 3)); 111 ANativeWindowBuffer* buf = 0; 112 113 status_t err = native_window_dequeue_buffer_and_wait(anw.get(), &buf); 114 if (err) { 115 // we could fail if GRALLOC_USAGE_PROTECTED is not supported. 116 // that's okay as long as this is the reason for the failure. 117 // try again without the GRALLOC_USAGE_PROTECTED bit. 118 ASSERT_EQ(NO_ERROR, native_window_set_usage(anw.get(), 0)); 119 ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(anw.get(), 120 &buf)); 121 return; 122 } 123 ASSERT_EQ(NO_ERROR, anw->cancelBuffer(anw.get(), buf, -1)); 124 125 for (int i = 0; i < 4; i++) { 126 // Loop to make sure SurfaceFlinger has retired a protected buffer. 127 ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(anw.get(), 128 &buf)); 129 ASSERT_EQ(NO_ERROR, anw->queueBuffer(anw.get(), buf, -1)); 130 } 131 ASSERT_EQ(NO_ERROR, sf->captureScreen(display, producer, Rect(), 132 64, 64, 0, 0x7fffffff, false)); 133 } 134 135 TEST_F(SurfaceTest, ConcreteTypeIsSurface) { 136 sp<ANativeWindow> anw(mSurface); 137 int result = -123; 138 int err = anw->query(anw.get(), NATIVE_WINDOW_CONCRETE_TYPE, &result); 139 EXPECT_EQ(NO_ERROR, err); 140 EXPECT_EQ(NATIVE_WINDOW_SURFACE, result); 141 } 142 143 TEST_F(SurfaceTest, QueryConsumerUsage) { 144 const int TEST_USAGE_FLAGS = 145 GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_HW_RENDER; 146 sp<IGraphicBufferProducer> producer; 147 sp<IGraphicBufferConsumer> consumer; 148 BufferQueue::createBufferQueue(&producer, &consumer); 149 sp<BufferItemConsumer> c = new BufferItemConsumer(consumer, 150 TEST_USAGE_FLAGS); 151 sp<Surface> s = new Surface(producer); 152 153 sp<ANativeWindow> anw(s); 154 155 int flags = -1; 156 int err = anw->query(anw.get(), NATIVE_WINDOW_CONSUMER_USAGE_BITS, &flags); 157 158 ASSERT_EQ(NO_ERROR, err); 159 ASSERT_EQ(TEST_USAGE_FLAGS, flags); 160 } 161 162 TEST_F(SurfaceTest, QueryDefaultBuffersDataSpace) { 163 const android_dataspace TEST_DATASPACE = HAL_DATASPACE_SRGB; 164 sp<IGraphicBufferProducer> producer; 165 sp<IGraphicBufferConsumer> consumer; 166 BufferQueue::createBufferQueue(&producer, &consumer); 167 sp<CpuConsumer> cpuConsumer = new CpuConsumer(consumer, 1); 168 169 cpuConsumer->setDefaultBufferDataSpace(TEST_DATASPACE); 170 171 sp<Surface> s = new Surface(producer); 172 173 sp<ANativeWindow> anw(s); 174 175 android_dataspace dataSpace; 176 177 int err = anw->query(anw.get(), NATIVE_WINDOW_DEFAULT_DATASPACE, 178 reinterpret_cast<int*>(&dataSpace)); 179 180 ASSERT_EQ(NO_ERROR, err); 181 ASSERT_EQ(TEST_DATASPACE, dataSpace); 182 } 183 184 TEST_F(SurfaceTest, SettingGenerationNumber) { 185 sp<IGraphicBufferProducer> producer; 186 sp<IGraphicBufferConsumer> consumer; 187 BufferQueue::createBufferQueue(&producer, &consumer); 188 sp<CpuConsumer> cpuConsumer = new CpuConsumer(consumer, 1); 189 sp<Surface> surface = new Surface(producer); 190 sp<ANativeWindow> window(surface); 191 192 // Allocate a buffer with a generation number of 0 193 ANativeWindowBuffer* buffer; 194 int fenceFd; 195 ASSERT_EQ(NO_ERROR, native_window_api_connect(window.get(), 196 NATIVE_WINDOW_API_CPU)); 197 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fenceFd)); 198 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fenceFd)); 199 200 // Detach the buffer and check its generation number 201 sp<GraphicBuffer> graphicBuffer; 202 sp<Fence> fence; 203 ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&graphicBuffer, &fence)); 204 ASSERT_EQ(0U, graphicBuffer->getGenerationNumber()); 205 206 ASSERT_EQ(NO_ERROR, surface->setGenerationNumber(1)); 207 buffer = static_cast<ANativeWindowBuffer*>(graphicBuffer.get()); 208 209 // This should change the generation number of the GraphicBuffer 210 ASSERT_EQ(NO_ERROR, surface->attachBuffer(buffer)); 211 212 // Check that the new generation number sticks with the buffer 213 ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, -1)); 214 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fenceFd)); 215 graphicBuffer = static_cast<GraphicBuffer*>(buffer); 216 ASSERT_EQ(1U, graphicBuffer->getGenerationNumber()); 217 } 218 219 TEST_F(SurfaceTest, GetConsumerName) { 220 sp<IGraphicBufferProducer> producer; 221 sp<IGraphicBufferConsumer> consumer; 222 BufferQueue::createBufferQueue(&producer, &consumer); 223 224 sp<DummyConsumer> dummyConsumer(new DummyConsumer); 225 consumer->consumerConnect(dummyConsumer, false); 226 consumer->setConsumerName(String8("TestConsumer")); 227 228 sp<Surface> surface = new Surface(producer); 229 sp<ANativeWindow> window(surface); 230 native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU); 231 232 EXPECT_STREQ("TestConsumer", surface->getConsumerName().string()); 233 } 234 235 TEST_F(SurfaceTest, DynamicSetBufferCount) { 236 sp<IGraphicBufferProducer> producer; 237 sp<IGraphicBufferConsumer> consumer; 238 BufferQueue::createBufferQueue(&producer, &consumer); 239 240 sp<DummyConsumer> dummyConsumer(new DummyConsumer); 241 consumer->consumerConnect(dummyConsumer, false); 242 consumer->setConsumerName(String8("TestConsumer")); 243 244 sp<Surface> surface = new Surface(producer); 245 sp<ANativeWindow> window(surface); 246 247 ASSERT_EQ(NO_ERROR, native_window_api_connect(window.get(), 248 NATIVE_WINDOW_API_CPU)); 249 native_window_set_buffer_count(window.get(), 4); 250 251 int fence; 252 ANativeWindowBuffer* buffer; 253 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence)); 254 native_window_set_buffer_count(window.get(), 3); 255 ASSERT_EQ(NO_ERROR, window->queueBuffer(window.get(), buffer, fence)); 256 native_window_set_buffer_count(window.get(), 2); 257 ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence)); 258 ASSERT_EQ(NO_ERROR, window->queueBuffer(window.get(), buffer, fence)); 259 } 260 261 } 262
