1 /*
2 * Copyright (C) 2012 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_NDEBUG 0
18 #define LOG_TAG "CameraMetadataTestFunctional"
19 #include "cutils/log.h"
20 #include "cutils/properties.h"
21 #include "utils/Errors.h"
22
23 #include "gtest/gtest.h"
24 #include "system/camera_metadata.h"
25 #include "hardware/hardware.h"
26 #include "hardware/camera2.h"
27
28 #include "common/CameraDeviceBase.h"
29 #include "utils/StrongPointer.h"
30
31 #include <gui/CpuConsumer.h>
32 #include <gui/Surface.h>
33
34 #include <string>
35
36 #include "CameraStreamFixture.h"
37 #include "TestExtensions.h"
38
39 namespace android {
40 namespace camera2 {
41 namespace tests {
42
43 //FIXME: dont hardcode
44 static CameraStreamParams METADATA_STREAM_PARAMETERS = {
45 /*mFormat*/ HAL_PIXEL_FORMAT_YCrCb_420_SP,
46 /*mHeapCount*/ 2
47 };
48
49 class CameraMetadataTest
50 : public ::testing::Test,
51 public CameraStreamFixture {
52
53 public:
CameraMetadataTest()54 CameraMetadataTest()
55 : CameraStreamFixture(METADATA_STREAM_PARAMETERS) {
56 TEST_EXTENSION_FORKING_CONSTRUCTOR;
57 }
58
~CameraMetadataTest()59 ~CameraMetadataTest() {
60 TEST_EXTENSION_FORKING_DESTRUCTOR;
61 }
62
GetTypeFromTag(uint32_t tag) const63 int GetTypeFromTag(uint32_t tag) const {
64 return get_camera_metadata_tag_type(tag);
65 }
66
GetTypeFromStaticTag(uint32_t tag) const67 int GetTypeFromStaticTag(uint32_t tag) const {
68 const CameraMetadata& staticInfo = mDevice->info();
69 camera_metadata_ro_entry entry = staticInfo.find(tag);
70 return entry.type;
71 }
72
GetEntryCountFromStaticTag(uint32_t tag) const73 int GetEntryCountFromStaticTag(uint32_t tag) const {
74 const CameraMetadata& staticInfo = mDevice->info();
75 camera_metadata_ro_entry entry = staticInfo.find(tag);
76 return entry.count;
77 }
78
HasElementInArrayFromStaticTag(uint32_t tag,int32_t element) const79 bool HasElementInArrayFromStaticTag(uint32_t tag, int32_t element) const {
80 const CameraMetadata& staticInfo = mDevice->info();
81 camera_metadata_ro_entry entry = staticInfo.find(tag);
82 for (size_t i = 0; i < entry.count; ++i) {
83 if (entry.data.i32[i] == element)
84 return true;
85 }
86 return false;
87 }
88
89 protected:
90
91 };
92
TEST_F(CameraMetadataTest,types)93 TEST_F(CameraMetadataTest, types) {
94
95 TEST_EXTENSION_FORKING_INIT;
96
97 //FIXME: set this up in an external file of some sort (xml?)
98 {
99 char value[PROPERTY_VALUE_MAX];
100 property_get("ro.build.id", value, "");
101 std::string str_value(value);
102
103 if (str_value == "manta")
104 {
105 EXPECT_EQ(TYPE_BYTE,
106 GetTypeFromStaticTag(ANDROID_QUIRKS_TRIGGER_AF_WITH_AUTO));
107 EXPECT_EQ(TYPE_BYTE,
108 GetTypeFromStaticTag(ANDROID_QUIRKS_USE_ZSL_FORMAT));
109 EXPECT_EQ(TYPE_BYTE,
110 GetTypeFromStaticTag(ANDROID_QUIRKS_METERING_CROP_REGION));
111 }
112 }
113
114 /*
115 TODO:
116 go through all static metadata and make sure all fields we expect
117 that are there, ARE there.
118
119 dont worry about the type as its enforced by the metadata api
120 we can probably check the range validity though
121 */
122
123 if (0) {
124 camera_metadata_ro_entry entry;
125 EXPECT_EQ(TYPE_BYTE, entry.type);
126 EXPECT_EQ(TYPE_INT32, entry.type);
127 EXPECT_EQ(TYPE_FLOAT, entry.type);
128 EXPECT_EQ(TYPE_INT64, entry.type);
129 EXPECT_EQ(TYPE_DOUBLE, entry.type);
130 EXPECT_EQ(TYPE_RATIONAL, entry.type);
131 }
132 }
133
TEST_F(CameraMetadataTest,RequiredFormats)134 TEST_F(CameraMetadataTest, RequiredFormats) {
135 TEST_EXTENSION_FORKING_INIT;
136
137 EXPECT_TRUE(
138 HasElementInArrayFromStaticTag(ANDROID_SCALER_AVAILABLE_FORMATS,
139 HAL_PIXEL_FORMAT_BLOB)); // JPEG
140
141 if (getDeviceVersion() < CAMERA_DEVICE_API_VERSION_3_0) {
142 // HAL2 can support either flexible YUV or YV12 + NV21
143 if (!HasElementInArrayFromStaticTag(ANDROID_SCALER_AVAILABLE_FORMATS,
144 HAL_PIXEL_FORMAT_YCbCr_420_888)) {
145
146 EXPECT_TRUE(
147 HasElementInArrayFromStaticTag(ANDROID_SCALER_AVAILABLE_FORMATS,
148 HAL_PIXEL_FORMAT_YCrCb_420_SP)); // NV21
149
150 EXPECT_TRUE(
151 HasElementInArrayFromStaticTag(ANDROID_SCALER_AVAILABLE_FORMATS,
152 HAL_PIXEL_FORMAT_YV12));
153 }
154 } else {
155 // HAL3 must support flexible YUV
156 EXPECT_TRUE(HasElementInArrayFromStaticTag(ANDROID_SCALER_AVAILABLE_FORMATS,
157 HAL_PIXEL_FORMAT_YCbCr_420_888));
158 }
159
160 }
161
TEST_F(CameraMetadataTest,SaneResolutions)162 TEST_F(CameraMetadataTest, SaneResolutions) {
163 TEST_EXTENSION_FORKING_INIT;
164
165 if (getDeviceVersion() < CAMERA_DEVICE_API_VERSION_3_2) {
166 // Iff there are listed raw resolutions, the format should be available
167 int rawResolutionsCount =
168 GetEntryCountFromStaticTag(ANDROID_SCALER_AVAILABLE_RAW_SIZES);
169 if (rawResolutionsCount > 0) {
170 EXPECT_TRUE(
171 HasElementInArrayFromStaticTag(ANDROID_SCALER_AVAILABLE_FORMATS,
172 HAL_PIXEL_FORMAT_RAW16));
173 }
174
175 // Required processed sizes.
176 int processedSizeCount =
177 GetEntryCountFromStaticTag(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES);
178 EXPECT_NE(0, processedSizeCount);
179 EXPECT_EQ(0, processedSizeCount % 2); // multiple of 2 (w,h)
180
181 // Required JPEG sizes
182 int jpegSizeCount =
183 GetEntryCountFromStaticTag(ANDROID_SCALER_AVAILABLE_JPEG_SIZES);
184 EXPECT_NE(0, jpegSizeCount);
185 EXPECT_EQ(0, jpegSizeCount % 2); // multiple of 2 (w,h)
186 } else {
187 int strmConfigCount =
188 GetEntryCountFromStaticTag(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS);
189 EXPECT_NE(0, strmConfigCount);
190 EXPECT_EQ(0, strmConfigCount % 4); // multiple of 4 (format,w,h,output?)
191 }
192
193 }
194
195 }
196 }
197 }
198