| /* |
| * Copyright (C) 2013 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #define LOG_TAG "IGraphicBufferProducer_test" |
| //#define LOG_NDEBUG 0 |
| |
| #include <gtest/gtest.h> |
| |
| #include <utils/String8.h> |
| #include <utils/threads.h> |
| |
| #include <ui/GraphicBuffer.h> |
| |
| #include <gui/BufferQueue.h> |
| #include <gui/IProducerListener.h> |
| |
| #include <vector> |
| |
| #define ASSERT_OK(x) ASSERT_EQ(OK, (x)) |
| #define EXPECT_OK(x) EXPECT_EQ(OK, (x)) |
| |
| #define TEST_TOKEN ((IProducerListener*)(NULL)) |
| #define TEST_API NATIVE_WINDOW_API_CPU |
| #define TEST_API_OTHER NATIVE_WINDOW_API_EGL // valid API that's not TEST_API |
| #define TEST_CONTROLLED_BY_APP false |
| #define TEST_PRODUCER_USAGE_BITS (0) |
| |
| namespace android { |
| |
| namespace { |
| // Default dimensions before setDefaultBufferSize is called |
| const uint32_t DEFAULT_WIDTH = 1; |
| const uint32_t DEFAULT_HEIGHT = 1; |
| |
| // Default format before setDefaultBufferFormat is called |
| const PixelFormat DEFAULT_FORMAT = HAL_PIXEL_FORMAT_RGBA_8888; |
| |
| // Default transform hint before setTransformHint is called |
| const uint32_t DEFAULT_TRANSFORM_HINT = 0; |
| |
| // TODO: Make these constants in header |
| const int DEFAULT_CONSUMER_USAGE_BITS = 0; |
| |
| // Parameters for a generic "valid" input for queueBuffer. |
| const int64_t QUEUE_BUFFER_INPUT_TIMESTAMP = 1384888611; |
| const bool QUEUE_BUFFER_INPUT_IS_AUTO_TIMESTAMP = false; |
| const android_dataspace QUEUE_BUFFER_INPUT_DATASPACE = HAL_DATASPACE_UNKNOWN; |
| const Rect QUEUE_BUFFER_INPUT_RECT = Rect(DEFAULT_WIDTH, DEFAULT_HEIGHT); |
| const int QUEUE_BUFFER_INPUT_SCALING_MODE = 0; |
| const int QUEUE_BUFFER_INPUT_TRANSFORM = 0; |
| const sp<Fence> QUEUE_BUFFER_INPUT_FENCE = Fence::NO_FENCE; |
| }; // namespace anonymous |
| |
| struct DummyConsumer : public BnConsumerListener { |
| virtual void onFrameAvailable(const BufferItem& /* item */) {} |
| virtual void onBuffersReleased() {} |
| virtual void onSidebandStreamChanged() {} |
| }; |
| |
| class IGraphicBufferProducerTest : public ::testing::Test { |
| protected: |
| |
| IGraphicBufferProducerTest() {} |
| |
| virtual void SetUp() { |
| const ::testing::TestInfo* const testInfo = |
| ::testing::UnitTest::GetInstance()->current_test_info(); |
| ALOGV("Begin test: %s.%s", testInfo->test_case_name(), |
| testInfo->name()); |
| |
| mDC = new DummyConsumer; |
| |
| BufferQueue::createBufferQueue(&mProducer, &mConsumer); |
| |
| // Test check: Can't connect producer if no consumer yet |
| ASSERT_EQ(NO_INIT, TryConnectProducer()); |
| |
| // Must connect consumer before producer connects will succeed. |
| ASSERT_OK(mConsumer->consumerConnect(mDC, /*controlledByApp*/false)); |
| } |
| |
| virtual void TearDown() { |
| const ::testing::TestInfo* const testInfo = |
| ::testing::UnitTest::GetInstance()->current_test_info(); |
| ALOGV("End test: %s.%s", testInfo->test_case_name(), |
| testInfo->name()); |
| } |
| |
| status_t TryConnectProducer() { |
| IGraphicBufferProducer::QueueBufferOutput output; |
| return mProducer->connect(TEST_TOKEN, |
| TEST_API, |
| TEST_CONTROLLED_BY_APP, |
| &output); |
| // TODO: use params to vary token, api, producercontrolledbyapp, etc |
| } |
| |
| // Connect to a producer in a 'correct' fashion. |
| // Precondition: Consumer is connected. |
| void ConnectProducer() { |
| ASSERT_OK(TryConnectProducer()); |
| } |
| |
| // Create a generic "valid" input for queueBuffer |
| // -- uses the default buffer format, width, etc. |
| static IGraphicBufferProducer::QueueBufferInput CreateBufferInput() { |
| return QueueBufferInputBuilder().build(); |
| } |
| |
| // Builder pattern to slightly vary *almost* correct input |
| // -- avoids copying and pasting |
| struct QueueBufferInputBuilder { |
| QueueBufferInputBuilder() { |
| timestamp = QUEUE_BUFFER_INPUT_TIMESTAMP; |
| isAutoTimestamp = QUEUE_BUFFER_INPUT_IS_AUTO_TIMESTAMP; |
| dataSpace = QUEUE_BUFFER_INPUT_DATASPACE; |
| crop = QUEUE_BUFFER_INPUT_RECT; |
| scalingMode = QUEUE_BUFFER_INPUT_SCALING_MODE; |
| transform = QUEUE_BUFFER_INPUT_TRANSFORM; |
| fence = QUEUE_BUFFER_INPUT_FENCE; |
| } |
| |
| IGraphicBufferProducer::QueueBufferInput build() { |
| return IGraphicBufferProducer::QueueBufferInput( |
| timestamp, |
| isAutoTimestamp, |
| dataSpace, |
| crop, |
| scalingMode, |
| transform, |
| fence); |
| } |
| |
| QueueBufferInputBuilder& setTimestamp(int64_t timestamp) { |
| this->timestamp = timestamp; |
| return *this; |
| } |
| |
| QueueBufferInputBuilder& setIsAutoTimestamp(bool isAutoTimestamp) { |
| this->isAutoTimestamp = isAutoTimestamp; |
| return *this; |
| } |
| |
| QueueBufferInputBuilder& setDataSpace(android_dataspace dataSpace) { |
| this->dataSpace = dataSpace; |
| return *this; |
| } |
| |
| QueueBufferInputBuilder& setCrop(Rect crop) { |
| this->crop = crop; |
| return *this; |
| } |
| |
| QueueBufferInputBuilder& setScalingMode(int scalingMode) { |
| this->scalingMode = scalingMode; |
| return *this; |
| } |
| |
| QueueBufferInputBuilder& setTransform(uint32_t transform) { |
| this->transform = transform; |
| return *this; |
| } |
| |
| QueueBufferInputBuilder& setFence(sp<Fence> fence) { |
| this->fence = fence; |
| return *this; |
| } |
| |
| private: |
| int64_t timestamp; |
| bool isAutoTimestamp; |
| android_dataspace dataSpace; |
| Rect crop; |
| int scalingMode; |
| uint32_t transform; |
| sp<Fence> fence; |
| }; // struct QueueBufferInputBuilder |
| |
| // To easily store dequeueBuffer results into containers |
| struct DequeueBufferResult { |
| int slot; |
| sp<Fence> fence; |
| }; |
| |
| status_t dequeueBuffer(uint32_t w, uint32_t h, uint32_t format, uint32_t usage, DequeueBufferResult* result) { |
| return mProducer->dequeueBuffer(&result->slot, &result->fence, w, h, format, usage); |
| } |
| |
| void setupDequeueRequestBuffer(int *slot, sp<Fence> *fence, |
| sp<GraphicBuffer> *buffer) |
| { |
| ASSERT_TRUE(slot != NULL); |
| ASSERT_TRUE(fence != NULL); |
| ASSERT_TRUE(buffer != NULL); |
| |
| ASSERT_NO_FATAL_FAILURE(ConnectProducer()); |
| |
| ASSERT_EQ(OK, ~IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION & |
| (mProducer->dequeueBuffer(slot, fence, DEFAULT_WIDTH, |
| DEFAULT_HEIGHT, DEFAULT_FORMAT, TEST_PRODUCER_USAGE_BITS))); |
| |
| EXPECT_LE(0, *slot); |
| EXPECT_GT(BufferQueue::NUM_BUFFER_SLOTS, *slot); |
| |
| // Request the buffer (pre-requisite for queueing) |
| ASSERT_OK(mProducer->requestBuffer(*slot, buffer)); |
| } |
| |
| private: // hide from test body |
| sp<DummyConsumer> mDC; |
| |
| protected: // accessible from test body |
| sp<IGraphicBufferProducer> mProducer; |
| sp<IGraphicBufferConsumer> mConsumer; |
| }; |
| |
| TEST_F(IGraphicBufferProducerTest, ConnectFirst_ReturnsError) { |
| IGraphicBufferProducer::QueueBufferOutput output; |
| |
| // NULL output returns BAD_VALUE |
| EXPECT_EQ(BAD_VALUE, mProducer->connect(TEST_TOKEN, |
| TEST_API, |
| TEST_CONTROLLED_BY_APP, |
| /*output*/NULL)); |
| |
| // Invalid API returns bad value |
| EXPECT_EQ(BAD_VALUE, mProducer->connect(TEST_TOKEN, |
| /*api*/0xDEADBEEF, |
| TEST_CONTROLLED_BY_APP, |
| &output)); |
| |
| // TODO: get a token from a dead process somehow |
| } |
| |
| TEST_F(IGraphicBufferProducerTest, ConnectAgain_ReturnsError) { |
| ASSERT_NO_FATAL_FAILURE(ConnectProducer()); |
| |
| // Can't connect when there is already a producer connected |
| IGraphicBufferProducer::QueueBufferOutput output; |
| EXPECT_EQ(BAD_VALUE, mProducer->connect(TEST_TOKEN, |
| TEST_API, |
| TEST_CONTROLLED_BY_APP, |
| &output)); |
| |
| ASSERT_OK(mConsumer->consumerDisconnect()); |
| // Can't connect when IGBP is abandoned |
| EXPECT_EQ(NO_INIT, mProducer->connect(TEST_TOKEN, |
| TEST_API, |
| TEST_CONTROLLED_BY_APP, |
| &output)); |
| } |
| |
| TEST_F(IGraphicBufferProducerTest, Disconnect_Succeeds) { |
| ASSERT_NO_FATAL_FAILURE(ConnectProducer()); |
| |
| ASSERT_OK(mProducer->disconnect(TEST_API)); |
| } |
| |
| |
| TEST_F(IGraphicBufferProducerTest, Disconnect_ReturnsError) { |
| ASSERT_NO_FATAL_FAILURE(ConnectProducer()); |
| |
| // Must disconnect with same API number |
| ASSERT_EQ(BAD_VALUE, mProducer->disconnect(TEST_API_OTHER)); |
| // API must not be out of range |
| ASSERT_EQ(BAD_VALUE, mProducer->disconnect(/*api*/0xDEADBEEF)); |
| |
| // TODO: somehow kill mProducer so that this returns DEAD_OBJECT |
| } |
| |
| TEST_F(IGraphicBufferProducerTest, Query_Succeeds) { |
| ASSERT_NO_FATAL_FAILURE(ConnectProducer()); |
| |
| int32_t value = -1; |
| EXPECT_OK(mProducer->query(NATIVE_WINDOW_WIDTH, &value)); |
| EXPECT_EQ(DEFAULT_WIDTH, static_cast<uint32_t>(value)); |
| |
| EXPECT_OK(mProducer->query(NATIVE_WINDOW_HEIGHT, &value)); |
| EXPECT_EQ(DEFAULT_HEIGHT, static_cast<uint32_t>(value)); |
| |
| EXPECT_OK(mProducer->query(NATIVE_WINDOW_FORMAT, &value)); |
| EXPECT_EQ(DEFAULT_FORMAT, value); |
| |
| EXPECT_OK(mProducer->query(NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, &value)); |
| EXPECT_LE(0, value); |
| EXPECT_GE(BufferQueue::NUM_BUFFER_SLOTS, value); |
| |
| EXPECT_OK(mProducer->query(NATIVE_WINDOW_CONSUMER_RUNNING_BEHIND, &value)); |
| EXPECT_FALSE(value); // Can't run behind when we haven't touched the queue |
| |
| EXPECT_OK(mProducer->query(NATIVE_WINDOW_CONSUMER_USAGE_BITS, &value)); |
| EXPECT_EQ(DEFAULT_CONSUMER_USAGE_BITS, value); |
| |
| } |
| |
| TEST_F(IGraphicBufferProducerTest, Query_ReturnsError) { |
| ASSERT_NO_FATAL_FAILURE(ConnectProducer()); |
| |
| // One past the end of the last 'query' enum value. Update this if we add more enums. |
| const int NATIVE_WINDOW_QUERY_LAST_OFF_BY_ONE = NATIVE_WINDOW_BUFFER_AGE + 1; |
| |
| int value; |
| // What was out of range |
| EXPECT_EQ(BAD_VALUE, mProducer->query(/*what*/-1, &value)); |
| EXPECT_EQ(BAD_VALUE, mProducer->query(/*what*/0xDEADBEEF, &value)); |
| EXPECT_EQ(BAD_VALUE, mProducer->query(NATIVE_WINDOW_QUERY_LAST_OFF_BY_ONE, &value)); |
| |
| // Some enums from window.h are 'invalid' |
| EXPECT_EQ(BAD_VALUE, mProducer->query(NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER, &value)); |
| EXPECT_EQ(BAD_VALUE, mProducer->query(NATIVE_WINDOW_CONCRETE_TYPE, &value)); |
| EXPECT_EQ(BAD_VALUE, mProducer->query(NATIVE_WINDOW_DEFAULT_WIDTH, &value)); |
| EXPECT_EQ(BAD_VALUE, mProducer->query(NATIVE_WINDOW_DEFAULT_HEIGHT, &value)); |
| EXPECT_EQ(BAD_VALUE, mProducer->query(NATIVE_WINDOW_TRANSFORM_HINT, &value)); |
| // TODO: Consider documented the above enums as unsupported or make a new enum for IGBP |
| |
| // Value was NULL |
| EXPECT_EQ(BAD_VALUE, mProducer->query(NATIVE_WINDOW_FORMAT, /*value*/NULL)); |
| |
| ASSERT_OK(mConsumer->consumerDisconnect()); |
| |
| // BQ was abandoned |
| EXPECT_EQ(NO_INIT, mProducer->query(NATIVE_WINDOW_FORMAT, &value)); |
| |
| // TODO: other things in window.h that are supported by Surface::query |
| // but not by BufferQueue::query |
| } |
| |
| // TODO: queue under more complicated situations not involving just a single buffer |
| TEST_F(IGraphicBufferProducerTest, Queue_Succeeds) { |
| ASSERT_NO_FATAL_FAILURE(ConnectProducer()); |
| |
| int dequeuedSlot = -1; |
| sp<Fence> dequeuedFence; |
| |
| |
| ASSERT_EQ(OK, ~IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION & |
| (mProducer->dequeueBuffer(&dequeuedSlot, &dequeuedFence, |
| DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_FORMAT, |
| TEST_PRODUCER_USAGE_BITS))); |
| |
| EXPECT_LE(0, dequeuedSlot); |
| EXPECT_GT(BufferQueue::NUM_BUFFER_SLOTS, dequeuedSlot); |
| |
| // Request the buffer (pre-requisite for queueing) |
| sp<GraphicBuffer> dequeuedBuffer; |
| ASSERT_OK(mProducer->requestBuffer(dequeuedSlot, &dequeuedBuffer)); |
| |
| // A generic "valid" input |
| IGraphicBufferProducer::QueueBufferInput input = CreateBufferInput(); |
| IGraphicBufferProducer::QueueBufferOutput output; |
| |
| // Queue the buffer back into the BQ |
| ASSERT_OK(mProducer->queueBuffer(dequeuedSlot, input, &output)); |
| |
| { |
| uint32_t width; |
| uint32_t height; |
| uint32_t transformHint; |
| uint32_t numPendingBuffers; |
| |
| output.deflate(&width, &height, &transformHint, &numPendingBuffers); |
| |
| EXPECT_EQ(DEFAULT_WIDTH, width); |
| EXPECT_EQ(DEFAULT_HEIGHT, height); |
| EXPECT_EQ(DEFAULT_TRANSFORM_HINT, transformHint); |
| EXPECT_EQ(1u, numPendingBuffers); // since queueBuffer was called exactly once |
| } |
| |
| // Buffer was not in the dequeued state |
| EXPECT_EQ(BAD_VALUE, mProducer->queueBuffer(dequeuedSlot, input, &output)); |
| } |
| |
| TEST_F(IGraphicBufferProducerTest, Queue_ReturnsError) { |
| ASSERT_NO_FATAL_FAILURE(ConnectProducer()); |
| |
| // Invalid slot number |
| { |
| // A generic "valid" input |
| IGraphicBufferProducer::QueueBufferInput input = CreateBufferInput(); |
| IGraphicBufferProducer::QueueBufferOutput output; |
| |
| EXPECT_EQ(BAD_VALUE, mProducer->queueBuffer(/*slot*/-1, input, &output)); |
| EXPECT_EQ(BAD_VALUE, mProducer->queueBuffer(/*slot*/0xDEADBEEF, input, &output)); |
| EXPECT_EQ(BAD_VALUE, mProducer->queueBuffer(BufferQueue::NUM_BUFFER_SLOTS, |
| input, &output)); |
| } |
| |
| // Slot was not in the dequeued state (all slots start out in Free state) |
| { |
| IGraphicBufferProducer::QueueBufferInput input = CreateBufferInput(); |
| IGraphicBufferProducer::QueueBufferOutput output; |
| |
| EXPECT_EQ(BAD_VALUE, mProducer->queueBuffer(/*slot*/0, input, &output)); |
| } |
| |
| // Put the slot into the "dequeued" state for the rest of the test |
| int dequeuedSlot = -1; |
| sp<Fence> dequeuedFence; |
| |
| ASSERT_EQ(OK, ~IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION & |
| (mProducer->dequeueBuffer(&dequeuedSlot, &dequeuedFence, |
| DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_FORMAT, |
| TEST_PRODUCER_USAGE_BITS))); |
| |
| // Slot was enqueued without requesting a buffer |
| { |
| IGraphicBufferProducer::QueueBufferInput input = CreateBufferInput(); |
| IGraphicBufferProducer::QueueBufferOutput output; |
| |
| EXPECT_EQ(BAD_VALUE, mProducer->queueBuffer(dequeuedSlot, input, &output)); |
| } |
| |
| // Request the buffer so that the rest of the tests don't fail on earlier checks. |
| sp<GraphicBuffer> dequeuedBuffer; |
| ASSERT_OK(mProducer->requestBuffer(dequeuedSlot, &dequeuedBuffer)); |
| |
| // Fence was NULL |
| { |
| sp<Fence> nullFence = NULL; |
| |
| IGraphicBufferProducer::QueueBufferInput input = |
| QueueBufferInputBuilder().setFence(nullFence).build(); |
| IGraphicBufferProducer::QueueBufferOutput output; |
| |
| EXPECT_EQ(BAD_VALUE, mProducer->queueBuffer(dequeuedSlot, input, &output)); |
| } |
| |
| // Scaling mode was unknown |
| { |
| IGraphicBufferProducer::QueueBufferInput input = |
| QueueBufferInputBuilder().setScalingMode(-1).build(); |
| IGraphicBufferProducer::QueueBufferOutput output; |
| |
| EXPECT_EQ(BAD_VALUE, mProducer->queueBuffer(dequeuedSlot, input, &output)); |
| |
| input = QueueBufferInputBuilder().setScalingMode(0xDEADBEEF).build(); |
| |
| EXPECT_EQ(BAD_VALUE, mProducer->queueBuffer(dequeuedSlot, input, &output)); |
| } |
| |
| // Crop rect is out of bounds of the buffer dimensions |
| { |
| IGraphicBufferProducer::QueueBufferInput input = |
| QueueBufferInputBuilder().setCrop(Rect(DEFAULT_WIDTH + 1, DEFAULT_HEIGHT + 1)) |
| .build(); |
| IGraphicBufferProducer::QueueBufferOutput output; |
| |
| EXPECT_EQ(BAD_VALUE, mProducer->queueBuffer(dequeuedSlot, input, &output)); |
| } |
| |
| // Abandon the buffer queue so that the last test fails |
| ASSERT_OK(mConsumer->consumerDisconnect()); |
| |
| // The buffer queue has been abandoned. |
| { |
| IGraphicBufferProducer::QueueBufferInput input = CreateBufferInput(); |
| IGraphicBufferProducer::QueueBufferOutput output; |
| |
| EXPECT_EQ(NO_INIT, mProducer->queueBuffer(dequeuedSlot, input, &output)); |
| } |
| } |
| |
| TEST_F(IGraphicBufferProducerTest, CancelBuffer_DoesntCrash) { |
| ASSERT_NO_FATAL_FAILURE(ConnectProducer()); |
| |
| int dequeuedSlot = -1; |
| sp<Fence> dequeuedFence; |
| |
| ASSERT_EQ(OK, ~IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION & |
| (mProducer->dequeueBuffer(&dequeuedSlot, &dequeuedFence, |
| DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_FORMAT, |
| TEST_PRODUCER_USAGE_BITS))); |
| |
| // No return code, but at least test that it doesn't blow up... |
| // TODO: add a return code |
| mProducer->cancelBuffer(dequeuedSlot, dequeuedFence); |
| } |
| |
| TEST_F(IGraphicBufferProducerTest, SetMaxDequeuedBufferCount_Succeeds) { |
| ASSERT_NO_FATAL_FAILURE(ConnectProducer()); |
| int minUndequeuedBuffers; |
| ASSERT_OK(mProducer->query(NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, |
| &minUndequeuedBuffers)); |
| |
| const int minBuffers = 1; |
| const int maxBuffers = BufferQueue::NUM_BUFFER_SLOTS - minUndequeuedBuffers; |
| |
| ASSERT_OK(mProducer->setAsyncMode(false)) << "async mode: " << false; |
| ASSERT_OK(mProducer->setMaxDequeuedBufferCount(minBuffers)) |
| << "bufferCount: " << minBuffers; |
| |
| // Should now be able to dequeue up to minBuffers times |
| DequeueBufferResult result; |
| for (int i = 0; i < minBuffers; ++i) { |
| |
| EXPECT_EQ(OK, ~IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION & |
| (dequeueBuffer(DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_FORMAT, |
| TEST_PRODUCER_USAGE_BITS, &result))) |
| << "iteration: " << i << ", slot: " << result.slot; |
| } |
| |
| ASSERT_OK(mProducer->setMaxDequeuedBufferCount(maxBuffers)); |
| |
| // queue the first buffer to enable max dequeued buffer count checking |
| IGraphicBufferProducer::QueueBufferInput input = CreateBufferInput(); |
| IGraphicBufferProducer::QueueBufferOutput output; |
| sp<GraphicBuffer> buffer; |
| ASSERT_OK(mProducer->requestBuffer(result.slot, &buffer)); |
| ASSERT_OK(mProducer->queueBuffer(result.slot, input, &output)); |
| |
| |
| // Should now be able to dequeue up to maxBuffers times |
| int dequeuedSlot = -1; |
| sp<Fence> dequeuedFence; |
| for (int i = 0; i < maxBuffers; ++i) { |
| |
| EXPECT_EQ(OK, ~IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION & |
| (mProducer->dequeueBuffer(&dequeuedSlot, &dequeuedFence, |
| DEFAULT_WIDTH, DEFAULT_HEIGHT, |
| DEFAULT_FORMAT, |
| TEST_PRODUCER_USAGE_BITS))) |
| << "iteration: " << i << ", slot: " << dequeuedSlot; |
| } |
| |
| // Cancel a buffer, so we can decrease the buffer count |
| ASSERT_OK(mProducer->cancelBuffer(dequeuedSlot, dequeuedFence)); |
| |
| // Should now be able to decrease the max dequeued count by 1 |
| ASSERT_OK(mProducer->setMaxDequeuedBufferCount(maxBuffers-1)); |
| } |
| |
| TEST_F(IGraphicBufferProducerTest, SetMaxDequeuedBufferCount_Fails) { |
| ASSERT_NO_FATAL_FAILURE(ConnectProducer()); |
| int minUndequeuedBuffers; |
| ASSERT_OK(mProducer->query(NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, |
| &minUndequeuedBuffers)); |
| |
| const int minBuffers = 1; |
| const int maxBuffers = BufferQueue::NUM_BUFFER_SLOTS - minUndequeuedBuffers; |
| |
| ASSERT_OK(mProducer->setAsyncMode(false)) << "async mode: " << false; |
| // Buffer count was out of range |
| EXPECT_EQ(BAD_VALUE, mProducer->setMaxDequeuedBufferCount(0)) |
| << "bufferCount: " << 0; |
| EXPECT_EQ(BAD_VALUE, mProducer->setMaxDequeuedBufferCount(maxBuffers + 1)) |
| << "bufferCount: " << maxBuffers + 1; |
| |
| // Set max dequeue count to 2 |
| ASSERT_OK(mProducer->setMaxDequeuedBufferCount(2)); |
| // Dequeue 2 buffers |
| int dequeuedSlot = -1; |
| sp<Fence> dequeuedFence; |
| for (int i = 0; i < 2; i++) { |
| ASSERT_EQ(OK, ~IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION & |
| (mProducer->dequeueBuffer(&dequeuedSlot, &dequeuedFence, |
| DEFAULT_WIDTH, DEFAULT_HEIGHT, |
| DEFAULT_FORMAT, |
| TEST_PRODUCER_USAGE_BITS))) |
| << "slot: " << dequeuedSlot; |
| } |
| |
| // Client has too many buffers dequeued |
| EXPECT_EQ(BAD_VALUE, mProducer->setMaxDequeuedBufferCount(1)) |
| << "bufferCount: " << minBuffers; |
| |
| // Abandon buffer queue |
| ASSERT_OK(mConsumer->consumerDisconnect()); |
| |
| // Fail because the buffer queue was abandoned |
| EXPECT_EQ(NO_INIT, mProducer->setMaxDequeuedBufferCount(minBuffers)) |
| << "bufferCount: " << minBuffers; |
| |
| } |
| |
| TEST_F(IGraphicBufferProducerTest, SetAsyncMode_Succeeds) { |
| ASSERT_OK(mConsumer->setMaxAcquiredBufferCount(1)) << "maxAcquire: " << 1; |
| ASSERT_NO_FATAL_FAILURE(ConnectProducer()); |
| ASSERT_OK(mProducer->setAsyncMode(true)) << "async mode: " << true; |
| ASSERT_OK(mProducer->setMaxDequeuedBufferCount(1)) << "maxDequeue: " << 1; |
| |
| int dequeuedSlot = -1; |
| sp<Fence> dequeuedFence; |
| IGraphicBufferProducer::QueueBufferInput input = CreateBufferInput(); |
| IGraphicBufferProducer::QueueBufferOutput output; |
| sp<GraphicBuffer> dequeuedBuffer; |
| |
| // Should now be able to queue/dequeue as many buffers as we want without |
| // blocking |
| for (int i = 0; i < 5; ++i) { |
| ASSERT_EQ(OK, ~IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION & |
| (mProducer->dequeueBuffer(&dequeuedSlot, &dequeuedFence, |
| DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_FORMAT, |
| TEST_PRODUCER_USAGE_BITS))) << "slot : " << dequeuedSlot; |
| ASSERT_OK(mProducer->requestBuffer(dequeuedSlot, &dequeuedBuffer)); |
| ASSERT_OK(mProducer->queueBuffer(dequeuedSlot, input, &output)); |
| } |
| } |
| |
| TEST_F(IGraphicBufferProducerTest, SetAsyncMode_Fails) { |
| ASSERT_NO_FATAL_FAILURE(ConnectProducer()); |
| // Prerequisite to fail out a valid setBufferCount call |
| { |
| int dequeuedSlot = -1; |
| sp<Fence> dequeuedFence; |
| |
| ASSERT_EQ(OK, ~IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION & |
| (mProducer->dequeueBuffer(&dequeuedSlot, &dequeuedFence, |
| DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_FORMAT, |
| TEST_PRODUCER_USAGE_BITS))) << "slot: " << dequeuedSlot; |
| } |
| |
| // Abandon buffer queue |
| ASSERT_OK(mConsumer->consumerDisconnect()); |
| |
| // Fail because the buffer queue was abandoned |
| EXPECT_EQ(NO_INIT, mProducer->setAsyncMode(false)) << "asyncMode: " |
| << false; |
| } |
| |
| TEST_F(IGraphicBufferProducerTest, |
| DisconnectedProducerReturnsError_dequeueBuffer) { |
| int slot = -1; |
| sp<Fence> fence; |
| |
| ASSERT_EQ(NO_INIT, mProducer->dequeueBuffer(&slot, &fence, DEFAULT_WIDTH, |
| DEFAULT_HEIGHT, DEFAULT_FORMAT, TEST_PRODUCER_USAGE_BITS)); |
| } |
| |
| TEST_F(IGraphicBufferProducerTest, |
| DisconnectedProducerReturnsError_detachNextBuffer) { |
| sp<Fence> fence; |
| sp<GraphicBuffer> buffer; |
| |
| ASSERT_EQ(NO_INIT, mProducer->detachNextBuffer(&buffer, &fence)); |
| } |
| |
| TEST_F(IGraphicBufferProducerTest, |
| DisconnectedProducerReturnsError_requestBuffer) { |
| ASSERT_NO_FATAL_FAILURE(ConnectProducer()); |
| |
| int slot = -1; |
| sp<Fence> fence; |
| |
| ASSERT_EQ(OK, ~IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION & |
| (mProducer->dequeueBuffer(&slot, &fence, DEFAULT_WIDTH, |
| DEFAULT_HEIGHT, DEFAULT_FORMAT, TEST_PRODUCER_USAGE_BITS))); |
| |
| EXPECT_LE(0, slot); |
| EXPECT_GT(BufferQueue::NUM_BUFFER_SLOTS, slot); |
| |
| ASSERT_OK(mProducer->disconnect(TEST_API)); |
| |
| sp<GraphicBuffer> buffer; |
| |
| ASSERT_EQ(NO_INIT, mProducer->requestBuffer(slot, &buffer)); |
| } |
| |
| |
| TEST_F(IGraphicBufferProducerTest, |
| DisconnectedProducerReturnsError_detachBuffer) { |
| int slot = -1; |
| sp<Fence> fence; |
| sp<GraphicBuffer> buffer; |
| |
| setupDequeueRequestBuffer(&slot, &fence, &buffer); |
| |
| ASSERT_OK(mProducer->disconnect(TEST_API)); |
| |
| ASSERT_EQ(NO_INIT, mProducer->detachBuffer(slot)); |
| } |
| |
| TEST_F(IGraphicBufferProducerTest, |
| DisconnectedProducerReturnsError_queueBuffer) { |
| int slot = -1; |
| sp<Fence> fence; |
| sp<GraphicBuffer> buffer; |
| |
| setupDequeueRequestBuffer(&slot, &fence, &buffer); |
| |
| ASSERT_OK(mProducer->disconnect(TEST_API)); |
| |
| // A generic "valid" input |
| IGraphicBufferProducer::QueueBufferInput input = CreateBufferInput(); |
| IGraphicBufferProducer::QueueBufferOutput output; |
| |
| ASSERT_EQ(NO_INIT, mProducer->queueBuffer(slot, input, &output)); |
| } |
| |
| TEST_F(IGraphicBufferProducerTest, |
| DisconnectedProducerReturnsError_cancelBuffer) { |
| int slot = -1; |
| sp<Fence> fence; |
| sp<GraphicBuffer> buffer; |
| |
| setupDequeueRequestBuffer(&slot, &fence, &buffer); |
| |
| ASSERT_OK(mProducer->disconnect(TEST_API)); |
| |
| ASSERT_EQ(NO_INIT, mProducer->cancelBuffer(slot, fence)); |
| } |
| |
| TEST_F(IGraphicBufferProducerTest, |
| DisconnectedProducerReturnsError_attachBuffer) { |
| int slot = -1; |
| sp<Fence> fence; |
| sp<GraphicBuffer> buffer; |
| |
| setupDequeueRequestBuffer(&slot, &fence, &buffer); |
| |
| ASSERT_OK(mProducer->detachBuffer(slot)); |
| |
| ASSERT_OK(mProducer->disconnect(TEST_API)); |
| |
| ASSERT_EQ(NO_INIT, mProducer->attachBuffer(&slot, buffer)); |
| } |
| |
| } // namespace android |
