1 /*
2  * Copyright 2014 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 "StreamSplitter_test"
18 //#define LOG_NDEBUG 0
19 
20 #include <gui/BufferItem.h>
21 #include <gui/BufferQueue.h>
22 #include <gui/IConsumerListener.h>
23 #include <gui/ISurfaceComposer.h>
24 #include <gui/StreamSplitter.h>
25 #include <private/gui/ComposerService.h>
26 
27 #include <system/window.h>
28 
29 #include <gtest/gtest.h>
30 
31 namespace android {
32 
33 class StreamSplitterTest : public ::testing::Test {
34 
35 protected:
StreamSplitterTest()36     StreamSplitterTest() {
37         const ::testing::TestInfo* const testInfo =
38             ::testing::UnitTest::GetInstance()->current_test_info();
39         ALOGV("Begin test: %s.%s", testInfo->test_case_name(),
40                 testInfo->name());
41     }
42 
~StreamSplitterTest()43     ~StreamSplitterTest() {
44         const ::testing::TestInfo* const testInfo =
45             ::testing::UnitTest::GetInstance()->current_test_info();
46         ALOGV("End test:   %s.%s", testInfo->test_case_name(),
47                 testInfo->name());
48     }
49 };
50 
51 struct FakeListener : public BnConsumerListener {
onFrameAvailableandroid::FakeListener52     virtual void onFrameAvailable(const BufferItem& /* item */) {}
onBuffersReleasedandroid::FakeListener53     virtual void onBuffersReleased() {}
onSidebandStreamChangedandroid::FakeListener54     virtual void onSidebandStreamChanged() {}
55 };
56 
57 static const uint32_t TEST_DATA = 0x12345678u;
58 
TEST_F(StreamSplitterTest,OneInputOneOutput)59 TEST_F(StreamSplitterTest, OneInputOneOutput) {
60     sp<IGraphicBufferProducer> inputProducer;
61     sp<IGraphicBufferConsumer> inputConsumer;
62     BufferQueue::createBufferQueue(&inputProducer, &inputConsumer);
63 
64     sp<IGraphicBufferProducer> outputProducer;
65     sp<IGraphicBufferConsumer> outputConsumer;
66     BufferQueue::createBufferQueue(&outputProducer, &outputConsumer);
67     ASSERT_EQ(OK, outputConsumer->consumerConnect(new FakeListener, false));
68 
69     sp<StreamSplitter> splitter;
70     status_t status = StreamSplitter::createSplitter(inputConsumer, &splitter);
71     ASSERT_EQ(OK, status);
72     ASSERT_EQ(OK, splitter->addOutput(outputProducer));
73 
74     // Never allow the output BufferQueue to allocate a buffer
75     ASSERT_EQ(OK, outputProducer->allowAllocation(false));
76 
77     IGraphicBufferProducer::QueueBufferOutput qbOutput;
78     ASSERT_EQ(OK,
79               inputProducer->connect(new StubProducerListener, NATIVE_WINDOW_API_CPU, false,
80                                      &qbOutput));
81 
82     int slot;
83     sp<Fence> fence;
84     sp<GraphicBuffer> buffer;
85     ASSERT_EQ(IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION,
86               inputProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, GRALLOC_USAGE_SW_WRITE_OFTEN,
87                                            nullptr, nullptr));
88     ASSERT_EQ(OK, inputProducer->requestBuffer(slot, &buffer));
89 
90     uint32_t* dataIn;
91     ASSERT_EQ(OK, buffer->lock(GraphicBuffer::USAGE_SW_WRITE_OFTEN,
92             reinterpret_cast<void**>(&dataIn)));
93     *dataIn = TEST_DATA;
94     ASSERT_EQ(OK, buffer->unlock());
95 
96     IGraphicBufferProducer::QueueBufferInput qbInput(0, false,
97             HAL_DATASPACE_UNKNOWN, Rect(0, 0, 1, 1),
98             NATIVE_WINDOW_SCALING_MODE_FREEZE, 0, Fence::NO_FENCE);
99     ASSERT_EQ(OK, inputProducer->queueBuffer(slot, qbInput, &qbOutput));
100 
101     // Now that we have dequeued/allocated one buffer, prevent any further
102     // allocations
103     ASSERT_EQ(OK, inputProducer->allowAllocation(false));
104 
105     BufferItem item;
106     ASSERT_EQ(OK, outputConsumer->acquireBuffer(&item, 0));
107 
108     uint32_t* dataOut;
109     ASSERT_EQ(OK, item.mGraphicBuffer->lock(GraphicBuffer::USAGE_SW_READ_OFTEN,
110             reinterpret_cast<void**>(&dataOut)));
111     ASSERT_EQ(*dataOut, TEST_DATA);
112     ASSERT_EQ(OK, item.mGraphicBuffer->unlock());
113 
114     ASSERT_EQ(OK, outputConsumer->releaseBuffer(item.mSlot, item.mFrameNumber,
115             EGL_NO_DISPLAY, EGL_NO_SYNC_KHR, Fence::NO_FENCE));
116 
117     // This should succeed even with allocation disabled since it will have
118     // received the buffer back from the output BufferQueue
119     ASSERT_EQ(IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION,
120               inputProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, GRALLOC_USAGE_SW_WRITE_OFTEN,
121                                            nullptr, nullptr));
122 }
123 
TEST_F(StreamSplitterTest,OneInputMultipleOutputs)124 TEST_F(StreamSplitterTest, OneInputMultipleOutputs) {
125     const int NUM_OUTPUTS = 4;
126 
127     sp<IGraphicBufferProducer> inputProducer;
128     sp<IGraphicBufferConsumer> inputConsumer;
129     BufferQueue::createBufferQueue(&inputProducer, &inputConsumer);
130 
131     sp<IGraphicBufferProducer> outputProducers[NUM_OUTPUTS] = {};
132     sp<IGraphicBufferConsumer> outputConsumers[NUM_OUTPUTS] = {};
133     for (int output = 0; output < NUM_OUTPUTS; ++output) {
134         BufferQueue::createBufferQueue(&outputProducers[output],
135                 &outputConsumers[output]);
136         ASSERT_EQ(OK, outputConsumers[output]->consumerConnect(new FakeListener, false));
137     }
138 
139     sp<StreamSplitter> splitter;
140     status_t status = StreamSplitter::createSplitter(inputConsumer, &splitter);
141     ASSERT_EQ(OK, status);
142     for (int output = 0; output < NUM_OUTPUTS; ++output) {
143         ASSERT_EQ(OK, splitter->addOutput(outputProducers[output]));
144 
145         // Never allow the output BufferQueues to allocate a buffer
146         ASSERT_EQ(OK, outputProducers[output]->allowAllocation(false));
147     }
148 
149     IGraphicBufferProducer::QueueBufferOutput qbOutput;
150     ASSERT_EQ(OK,
151               inputProducer->connect(new StubProducerListener, NATIVE_WINDOW_API_CPU, false,
152                                      &qbOutput));
153 
154     int slot;
155     sp<Fence> fence;
156     sp<GraphicBuffer> buffer;
157     ASSERT_EQ(IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION,
158               inputProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, GRALLOC_USAGE_SW_WRITE_OFTEN,
159                                            nullptr, nullptr));
160     ASSERT_EQ(OK, inputProducer->requestBuffer(slot, &buffer));
161 
162     uint32_t* dataIn;
163     ASSERT_EQ(OK, buffer->lock(GraphicBuffer::USAGE_SW_WRITE_OFTEN,
164             reinterpret_cast<void**>(&dataIn)));
165     *dataIn = TEST_DATA;
166     ASSERT_EQ(OK, buffer->unlock());
167 
168     IGraphicBufferProducer::QueueBufferInput qbInput(0, false,
169             HAL_DATASPACE_UNKNOWN, Rect(0, 0, 1, 1),
170             NATIVE_WINDOW_SCALING_MODE_FREEZE, 0, Fence::NO_FENCE);
171     ASSERT_EQ(OK, inputProducer->queueBuffer(slot, qbInput, &qbOutput));
172 
173     // Now that we have dequeued/allocated one buffer, prevent any further
174     // allocations
175     ASSERT_EQ(OK, inputProducer->allowAllocation(false));
176 
177     for (int output = 0; output < NUM_OUTPUTS; ++output) {
178         BufferItem item;
179         ASSERT_EQ(OK, outputConsumers[output]->acquireBuffer(&item, 0));
180 
181         uint32_t* dataOut;
182         ASSERT_EQ(OK, item.mGraphicBuffer->lock(GraphicBuffer::USAGE_SW_READ_OFTEN,
183                     reinterpret_cast<void**>(&dataOut)));
184         ASSERT_EQ(*dataOut, TEST_DATA);
185         ASSERT_EQ(OK, item.mGraphicBuffer->unlock());
186 
187         ASSERT_EQ(OK, outputConsumers[output]->releaseBuffer(item.mSlot,
188                     item.mFrameNumber, EGL_NO_DISPLAY, EGL_NO_SYNC_KHR,
189                     Fence::NO_FENCE));
190     }
191 
192     // This should succeed even with allocation disabled since it will have
193     // received the buffer back from the output BufferQueues
194     ASSERT_EQ(IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION,
195               inputProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, GRALLOC_USAGE_SW_WRITE_OFTEN,
196                                            nullptr, nullptr));
197 }
198 
TEST_F(StreamSplitterTest,OutputAbandonment)199 TEST_F(StreamSplitterTest, OutputAbandonment) {
200     sp<IGraphicBufferProducer> inputProducer;
201     sp<IGraphicBufferConsumer> inputConsumer;
202     BufferQueue::createBufferQueue(&inputProducer, &inputConsumer);
203 
204     sp<IGraphicBufferProducer> outputProducer;
205     sp<IGraphicBufferConsumer> outputConsumer;
206     BufferQueue::createBufferQueue(&outputProducer, &outputConsumer);
207     ASSERT_EQ(OK, outputConsumer->consumerConnect(new FakeListener, false));
208 
209     sp<StreamSplitter> splitter;
210     status_t status = StreamSplitter::createSplitter(inputConsumer, &splitter);
211     ASSERT_EQ(OK, status);
212     ASSERT_EQ(OK, splitter->addOutput(outputProducer));
213 
214     IGraphicBufferProducer::QueueBufferOutput qbOutput;
215     ASSERT_EQ(OK,
216               inputProducer->connect(new StubProducerListener, NATIVE_WINDOW_API_CPU, false,
217                                      &qbOutput));
218 
219     int slot;
220     sp<Fence> fence;
221     sp<GraphicBuffer> buffer;
222     ASSERT_EQ(IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION,
223               inputProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, GRALLOC_USAGE_SW_WRITE_OFTEN,
224                                            nullptr, nullptr));
225     ASSERT_EQ(OK, inputProducer->requestBuffer(slot, &buffer));
226 
227     // Abandon the output
228     outputConsumer->consumerDisconnect();
229 
230     IGraphicBufferProducer::QueueBufferInput qbInput(0, false,
231             HAL_DATASPACE_UNKNOWN, Rect(0, 0, 1, 1),
232             NATIVE_WINDOW_SCALING_MODE_FREEZE, 0, Fence::NO_FENCE);
233     ASSERT_EQ(OK, inputProducer->queueBuffer(slot, qbInput, &qbOutput));
234 
235     // Input should be abandoned
236     ASSERT_EQ(NO_INIT,
237               inputProducer->dequeueBuffer(&slot, &fence, 0, 0, 0, GRALLOC_USAGE_SW_WRITE_OFTEN,
238                                            nullptr, nullptr));
239 }
240 
241 } // namespace android
242