1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include <v4l2_dev.h>
18 #include <v4l2_uvc.h>
19
20 #include "utest_v4l2.h"
21
22 using namespace testing::ext;
23 namespace OHOS::Camera {
V4L2UvcCallback(const std::string cameraId,const std::vector<DeviceControl> & control,const std::vector<DeviceFormat> & fromat,const bool inOut)24 void V4L2UvcCallback(const std::string cameraId, const std::vector<DeviceControl>& control,
25 const std::vector<DeviceFormat>& fromat, const bool inOut)
26 {
27 std::cout << "V4L2UvcCallback" << std::endl;
28 }
29
V4L2BufferCallback(std::shared_ptr<FrameSpec> buffer)30 void V4L2BufferCallback(std::shared_ptr<FrameSpec> buffer)
31 {
32 std::cout << "V4L2BufferCallback" << std::endl;
33 }
34
SetUpTestCase(void)35 void UtestV4L2Dev::SetUpTestCase(void)
36 {
37 std::cout << "SetUpTestCase.." << std::endl;
38
39 V4L2UVC_ = std::make_shared<HosV4L2UVC>();
40 EXPECT_EQ(true, V4L2UVC_ != nullptr);
41
42 V4L2Dev_ = std::make_shared<HosV4L2Dev>();
43 EXPECT_EQ(true, V4L2Dev_ != nullptr);
44 }
45
TearDownTestCase(void)46 void UtestV4L2Dev::TearDownTestCase(void)
47 {
48 std::cout << "TearDownTestCase.." << std::endl;
49 }
50
SetUp(void)51 void UtestV4L2Dev::SetUp(void)
52 {
53 std::cout << "SetUp.." << std::endl;
54 }
55
TearDown(void)56 void UtestV4L2Dev::TearDown(void)
57 {
58 std::cout << "TearDown.." << std::endl;
59 }
60
61 HWTEST_F(UtestV4L2Dev, InitUvc, TestSize.Level0)
62 {
63 V4L2UVC_->V4L2UvcDetectInit(V4L2UvcCallback);
64 }
65
66 HWTEST_F(UtestV4L2Dev, InitCamera, TestSize.Level0)
67 {
68 int rc = 0;
69
70 cameraIDs_.push_back("rkisp_v5");
71 rc = HosV4L2Dev::Init(cameraIDs_);
72
73 EXPECT_EQ(true, rc != RC_ERROR);
74 }
75
76 HWTEST_F(UtestV4L2Dev, SetFormat, TestSize.Level0)
77 {
78 constexpr uint32_t width = 640;
79 constexpr uint32_t height = 480;
80
81 int rc = 0;
82 std::string devname = "rkisp_v5";
83 DeviceFormat format = {};
84
85 rc = V4L2Dev_->start(devname);
86 EXPECT_EQ(RC_OK, rc);
87
88 rc = V4L2Dev_->ConfigSys(devname, CMD_V4L2_GET_FORMAT, format);
89 EXPECT_EQ(RC_OK, rc);
90
91 format.fmtdesc.pixelformat = V4L2_PIX_FMT_YUYV;
92 format.fmtdesc.width = width;
93 format.fmtdesc.height = height;
94
95 rc = V4L2Dev_->ConfigSys(devname, CMD_V4L2_SET_FORMAT, format);
96 EXPECT_EQ(RC_OK, rc);
97
98 rc = V4L2Dev_->ConfigSys(devname, CMD_V4L2_GET_FPS, format);
99 EXPECT_EQ(RC_OK, rc);
100 }
101
102 HWTEST_F(UtestV4L2Dev, SetBuffer, TestSize.Level0)
103 {
104 constexpr uint32_t bufferCount = 4;
105
106 unsigned char* addr[bufferCount];
107 std::shared_ptr<FrameSpec> buffptr[bufferCount];
108 std::string devname = "rkisp_v5";
109 DeviceFormat format = {};
110 unsigned int bufSize;
111 int i;
112 int rc = 0;
113
114 rc = V4L2Dev_->ReqBuffers(devname, bufferCount);
115 EXPECT_EQ(RC_OK, rc);
116
117 rc = V4L2Dev_->ConfigSys(devname, CMD_V4L2_GET_FORMAT, format);
118 EXPECT_EQ(RC_OK, rc);
119
120 bufSize = format.fmtdesc.sizeimage;
121 for (i = 0; i < bufferCount; ++i) {
122 buffptr[i] = std::make_shared<FrameSpec>();
123 buffptr[i]->buffer_ = std::make_shared<IBuffer>();
124
125 buffptr[i]->buffer_->SetIndex(i);
126 buffptr[i]->buffer_->SetSize(bufSize);
127 buffptr[i]->buffer_->SetUsage(1);
128 buffptr[i]->bufferPoolId_ = 0;
129 addr[i] = (unsigned char*)malloc(bufSize);
130 if (addr == nullptr) {
131 std::cout << " malloc buffers fail \n" << std::endl;
132 break;
133 }
134 buffptr[i]->buffer_->SetVirAddress(addr[i]);
135
136 rc = V4L2Dev_->CreatBuffer(devname, buffptr[i]);
137 EXPECT_EQ(RC_OK, rc);
138 }
139
140 if (i != bufferCount) {
141 for (int j = 0; j < i; ++j) {
142 free(addr[j]);
143 }
144 V4L2Dev_->stop(devname);
145 }
146
147 EXPECT_EQ(bufferCount, i);
148 }
149
150
151 HWTEST_F(UtestV4L2Dev, SetFrameCallback, TestSize.Level0)
152 {
153 int rc = 0;
154
155 rc = V4L2Dev_->SetCallback(V4L2BufferCallback);
156 EXPECT_EQ(RC_OK, rc);
157 }
158
159 HWTEST_F(UtestV4L2Dev, StreamStart, TestSize.Level0)
160 {
161 int rc = 0;
162 int value;
163 std::string devname = "rkisp_v5";
164
165 constexpr uint32_t awbValue = 8;
166
167 rc = V4L2Dev_->StartStream(devname);
168 EXPECT_EQ(RC_OK, rc);
169
170 rc = V4L2Dev_->QuerySetting(devname, CMD_AWB_MODE, &value);
171 EXPECT_EQ(RC_OK, rc);
172
173 int setValue = awbValue;
174 rc = V4L2Dev_->UpdateSetting(devname, CMD_AWB_MODE, &setValue);
175 EXPECT_EQ(RC_OK, rc);
176
177 sleep(3);
178 }
179
180 HWTEST_F(UtestV4L2Dev, ReleaseAll, TestSize.Level0)
181 {
182 std::string devname = "rkisp_v5";
183
184 V4L2Dev_->StopStream(devname);
185 V4L2Dev_->ReleaseBuffers(devname);
186 V4L2Dev_->stop(devname);
187
188 V4L2UVC_->V4L2UvcDetectUnInit();
189 }
190 } // namespace OHOS::Camera
191