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 "Camera2Device.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_IMPLEMENTATION_DEFINED));
140
141 EXPECT_TRUE(
142 HasElementInArrayFromStaticTag(ANDROID_SCALER_AVAILABLE_FORMATS,
143 HAL_PIXEL_FORMAT_BLOB)); // JPEG
144
145 EXPECT_TRUE(
146 HasElementInArrayFromStaticTag(ANDROID_SCALER_AVAILABLE_FORMATS,
147 HAL_PIXEL_FORMAT_YCrCb_420_SP)); // NV21
148
149 EXPECT_TRUE(
150 HasElementInArrayFromStaticTag(ANDROID_SCALER_AVAILABLE_FORMATS,
151 HAL_PIXEL_FORMAT_YV12));
152 }
153
TEST_F(CameraMetadataTest,SaneResolutions)154 TEST_F(CameraMetadataTest, SaneResolutions) {
155 TEST_EXTENSION_FORKING_INIT;
156
157 // Iff there are listed raw resolutions, the format should be available
158 int rawResolutionsCount =
159 GetEntryCountFromStaticTag(HAL_PIXEL_FORMAT_RAW_SENSOR);
160 EXPECT_EQ(rawResolutionsCount > 0,
161 HasElementInArrayFromStaticTag(ANDROID_SCALER_AVAILABLE_FORMATS,
162 HAL_PIXEL_FORMAT_RAW_SENSOR));
163
164 // Required processed sizes.
165 int processedSizeCount =
166 GetEntryCountFromStaticTag(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES);
167 EXPECT_NE(0, processedSizeCount);
168 EXPECT_EQ(0, processedSizeCount % 2); // multiple of 2 (w,h)
169
170 // Required JPEG sizes
171 int jpegSizeCount =
172 GetEntryCountFromStaticTag(ANDROID_SCALER_AVAILABLE_JPEG_SIZES);
173 EXPECT_NE(0, jpegSizeCount);
174 EXPECT_EQ(0, jpegSizeCount % 2); // multiple of 2 (w,h)
175
176 }
177
178 }
179 }
180 }
181