1 /*
2 * Copyright (C) 2024 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 "Camera3StreamSplitterTest"
18 // #define LOG_NDEBUG 0
19
20 #include <android/hardware_buffer.h>
21 #include <com_android_graphics_libgui_flags.h>
22 #include <com_android_internal_camera_flags.h>
23 #include <gui/BufferItemConsumer.h>
24 #include <gui/IGraphicBufferConsumer.h>
25 #include <gui/Flags.h> // remove with WB_PLATFORM_API_IMPROVEMENTS
26 #if not COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_PLATFORM_API_IMPROVEMENTS)
27 #include <gui/IGraphicBufferProducer.h>
28 #endif
29 #include <gui/Surface.h>
30 #include <ui/Fence.h>
31 #include <ui/GraphicBuffer.h>
32 #include <ui/GraphicBufferAllocator.h>
33 #include <ui/PixelFormat.h>
34
35 #include <system/window.h>
36 #include <vndk/window.h>
37
38 #include <gtest/gtest.h>
39
40 #include "../device3/Flags.h"
41
42 #if USE_NEW_STREAM_SPLITTER
43 #include "../device3/Camera3StreamSplitter.h"
44 #else
45 #include "../device3/deprecated/DeprecatedCamera3StreamSplitter.h"
46 #endif // USE_NEW_STREAM_SPLITTER
47
48 using namespace android;
49
50 namespace {
51
52 uint64_t kConsumerUsage = AHARDWAREBUFFER_USAGE_CAMERA_READ;
53 uint64_t kProducerUsage = AHARDWAREBUFFER_USAGE_CAMERA_READ;
54 size_t kHalMaxBuffers = 3;
55 uint32_t kWidth = 640;
56 uint32_t kHeight = 480;
57 PixelFormat kFormat = HAL_PIXEL_FORMAT_YCBCR_420_888;
58 int64_t kDynamicRangeProfile = 0;
59
createConsumerAndSurface()60 std::tuple<sp<BufferItemConsumer>, sp<Surface>> createConsumerAndSurface() {
61 return BufferItemConsumer::create(kConsumerUsage);
62 }
63
64 class Camera3StreamSplitterTest : public testing::Test {
65 public:
SetUp()66 void SetUp() override {
67 #if USE_NEW_STREAM_SPLITTER
68 mSplitter = sp<Camera3StreamSplitter>::make();
69 #else
70 mSplitter = sp<DeprecatedCamera3StreamSplitter>::make();
71 #endif // USE_NEW_STREAM_SPLITTER
72 }
73
74 protected:
75 #if USE_NEW_STREAM_SPLITTER
76 sp<Camera3StreamSplitter> mSplitter;
77 #else
78 sp<DeprecatedCamera3StreamSplitter> mSplitter;
79 #endif // USE_NEW_STREAM_SPLITTER
80 };
81
82 class TestSurfaceListener : public SurfaceListener {
83 public:
onBufferReleased()84 virtual void onBufferReleased() override { mNumBuffersReleased++; }
needsReleaseNotify()85 virtual bool needsReleaseNotify() { return true; }
onBufferDetached(int)86 virtual void onBufferDetached(int) override {}
onBuffersDiscarded(const std::vector<sp<GraphicBuffer>> &)87 virtual void onBuffersDiscarded(const std::vector<sp<GraphicBuffer>>&) override {};
88
89 uint32_t mNumBuffersReleased = 0;
90 };
91
92 class TestConsumerListener : public BufferItemConsumer::FrameAvailableListener {
93 public:
TestConsumerListener(const wp<BufferItemConsumer> & consumer)94 TestConsumerListener(const wp<BufferItemConsumer>& consumer) : mConsumer(consumer) {}
95
onFrameAvailable(const BufferItem &)96 virtual void onFrameAvailable(const BufferItem&) {
97 sp<BufferItemConsumer> consumer = mConsumer.promote();
98 EXPECT_NE(nullptr, consumer);
99
100 BufferItem item;
101 EXPECT_EQ(OK, consumer->acquireBuffer(&item, 0));
102 mNumBuffersAcquired++;
103 EXPECT_EQ(OK, consumer->releaseBuffer(item, Fence::NO_FENCE));
104 }
onFrameReplaced(const BufferItem &)105 virtual void onFrameReplaced(const BufferItem&) {}
onFrameDequeued(const uint64_t)106 virtual void onFrameDequeued(const uint64_t) {}
onFrameCancelled(const uint64_t)107 virtual void onFrameCancelled(const uint64_t) {}
onFrameDetached(const uint64_t)108 virtual void onFrameDetached(const uint64_t) {}
109
110 wp<BufferItemConsumer> mConsumer;
111 uint32_t mNumBuffersAcquired = 0;
112 };
113
114 } // namespace
115
TEST_F(Camera3StreamSplitterTest,WithoutSurfaces_NoBuffersConsumed)116 TEST_F(Camera3StreamSplitterTest, WithoutSurfaces_NoBuffersConsumed) {
117 sp<Surface> consumer;
118 EXPECT_EQ(OK, mSplitter->connect({}, kConsumerUsage, kProducerUsage, kHalMaxBuffers, kWidth,
119 kHeight, kFormat, &consumer, kDynamicRangeProfile));
120
121 sp<TestSurfaceListener> surfaceListener = sp<TestSurfaceListener>::make();
122 EXPECT_EQ(OK, consumer->connect(NATIVE_WINDOW_API_CAMERA, surfaceListener, false));
123
124 sp<GraphicBuffer> buffer = new GraphicBuffer(kWidth, kHeight, kFormat, kProducerUsage);
125 EXPECT_EQ(OK, consumer->attachBuffer(buffer->getNativeBuffer()));
126 // TODO: Do this with the surface itself once the API is available.
127 EXPECT_EQ(OK,
128 ANativeWindow_queueBuffer(consumer.get(), buffer->getNativeBuffer(), /*fenceFd*/ -1));
129
130 EXPECT_EQ(0u, surfaceListener->mNumBuffersReleased);
131 }
132
TEST_F(Camera3StreamSplitterTest,TestProcessSingleBuffer)133 TEST_F(Camera3StreamSplitterTest, TestProcessSingleBuffer) {
134 //
135 // Set up output consumers:
136 //
137 constexpr auto kSurfaceId1 = 1;
138 auto [bufferItemConsumer1, surface1] = createConsumerAndSurface();
139 sp<TestConsumerListener> consumerListener1 =
140 sp<TestConsumerListener>::make(bufferItemConsumer1);
141 bufferItemConsumer1->setFrameAvailableListener(consumerListener1);
142
143 constexpr auto kSurfaceId2 = 2;
144 auto [bufferItemConsumer2, surface2] = createConsumerAndSurface();
145 sp<TestConsumerListener> consumerListener2 =
146 sp<TestConsumerListener>::make(bufferItemConsumer2);
147 bufferItemConsumer2->setFrameAvailableListener(consumerListener2);
148
149 //
150 // Connect it to the splitter, get the input surface, and set it up:
151 //
152 sp<Surface> inputSurface;
153 EXPECT_EQ(OK, mSplitter->connect({{kSurfaceId1, surface1}, {kSurfaceId2, surface2}},
154 kConsumerUsage, kProducerUsage, kHalMaxBuffers, kWidth,
155 kHeight, kFormat, &inputSurface, kDynamicRangeProfile));
156 sp<TestSurfaceListener> surfaceListener = sp<TestSurfaceListener>::make();
157 EXPECT_EQ(OK, inputSurface->connect(NATIVE_WINDOW_API_CAMERA, surfaceListener, false));
158 // TODO: Do this with the surface itself once the API is available.
159 #if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS(WB_PLATFORM_API_IMPROVEMENTS)
160 EXPECT_EQ(OK, inputSurface->allowAllocation(false));
161 #else
162 EXPECT_EQ(OK, inputSurface->getIGraphicBufferProducer()->allowAllocation(false));
163 #endif
164
165 //
166 // Create a buffer to use:
167 //
168 sp<GraphicBuffer> singleBuffer = new GraphicBuffer(kWidth, kHeight, kFormat, kProducerUsage);
169 EXPECT_NE(nullptr, singleBuffer);
170 mSplitter->attachBufferToOutputs(singleBuffer->getNativeBuffer(), {kSurfaceId1, kSurfaceId2});
171
172 //
173 // Verify that when we attach the buffer, it's processed appropriately:
174 //
175 EXPECT_EQ(OK, inputSurface->attachBuffer(singleBuffer->getNativeBuffer()));
176 EXPECT_EQ(OK, mSplitter->getOnFrameAvailableResult());
177 // TODO: Do this with the surface itself once the API is available.
178 EXPECT_EQ(OK, ANativeWindow_queueBuffer(inputSurface.get(), singleBuffer->getNativeBuffer(),
179 /*fenceFd*/ -1));
180
181 EXPECT_EQ(1u, consumerListener1->mNumBuffersAcquired);
182 EXPECT_EQ(1u, consumerListener2->mNumBuffersAcquired);
183 EXPECT_EQ(1u, surfaceListener->mNumBuffersReleased);
184 }
185