1 /*
2  * Copyright 2016 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 "V4L2MetadataFactory"
19 
20 #include "v4l2_metadata_factory.h"
21 
22 #include <camera/CameraMetadata.h>
23 #include "common.h"
24 #include "format_metadata_factory.h"
25 #include "metadata/boottime_state_delegate.h"
26 #include "metadata/control.h"
27 #include "metadata/enum_converter.h"
28 #include "metadata/partial_metadata_factory.h"
29 #include "metadata/property.h"
30 #include "metadata/scaling_converter.h"
31 
32 namespace v4l2_camera_hal {
33 
34 // According to spec, each unit of V4L2_CID_AUTO_EXPOSURE_BIAS is 0.001 EV.
35 const camera_metadata_rational_t kAeCompensationUnit = {1, 1000};
36 // According to spec, each unit of V4L2_CID_EXPOSURE_ABSOLUTE is 100 us.
37 const int64_t kV4L2ExposureTimeStepNs = 100000;
38 // According to spec, each unit of V4L2_CID_ISO_SENSITIVITY is ISO/1000.
39 const int32_t kV4L2SensitivityDenominator = 1000;
40 // Generously allow up to 6MB (the largest size on the RPi Camera is about 5MB).
41 const size_t kV4L2MaxJpegSize = 6000000;
42 
GetV4L2Metadata(std::shared_ptr<V4L2Wrapper> device,std::unique_ptr<Metadata> * result)43 int GetV4L2Metadata(std::shared_ptr<V4L2Wrapper> device,
44                     std::unique_ptr<Metadata>* result) {
45   HAL_LOG_ENTER();
46 
47   // Open a temporary connection to the device for all the V4L2 querying
48   // that will be happening (this could be done for each component individually,
49   // but doing it here prevents connecting and disconnecting for each one).
50   V4L2Wrapper::Connection temp_connection = V4L2Wrapper::Connection(device);
51   if (temp_connection.status()) {
52     HAL_LOGE("Failed to connect to device: %d.", temp_connection.status());
53     return temp_connection.status();
54   }
55 
56   // TODO(b/30035628): Add states.
57 
58   PartialMetadataSet components;
59 
60   components.insert(NoEffectMenuControl<uint8_t>(
61       ANDROID_COLOR_CORRECTION_ABERRATION_MODE,
62       ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES,
63       {ANDROID_COLOR_CORRECTION_ABERRATION_MODE_FAST,
64        ANDROID_COLOR_CORRECTION_ABERRATION_MODE_HIGH_QUALITY},
65       {{CAMERA3_TEMPLATE_STILL_CAPTURE,
66         ANDROID_COLOR_CORRECTION_ABERRATION_MODE_HIGH_QUALITY},
67        {OTHER_TEMPLATES, ANDROID_COLOR_CORRECTION_ABERRATION_MODE_FAST}}));
68 
69   // TODO(b/30510395): subcomponents of 3A.
70   // In general, default to ON/AUTO since they imply pretty much nothing,
71   // while OFF implies guarantees about not hindering performance.
72   components.insert(std::unique_ptr<PartialMetadataInterface>(
73       new Property<std::array<int32_t, 3>>(ANDROID_CONTROL_MAX_REGIONS,
74                                            {{/*AE*/ 0, /*AWB*/ 0, /*AF*/ 0}})));
75   // TODO(b/30921166): V4L2_CID_AUTO_EXPOSURE_BIAS is an int menu, so
76   // this will be falling back to NoEffect until int menu support is added.
77   components.insert(V4L2ControlOrDefault<int32_t>(
78       ControlType::kSlider,
79       ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION,
80       ANDROID_CONTROL_AE_COMPENSATION_RANGE,
81       device,
82       V4L2_CID_AUTO_EXPOSURE_BIAS,
83       // No scaling necessary, AE_COMPENSATION_STEP handles this.
84       std::make_shared<ScalingConverter<int32_t, int32_t>>(1, 1),
85       0,
86       {{OTHER_TEMPLATES, 0}}));
87   components.insert(std::unique_ptr<PartialMetadataInterface>(
88       new Property<camera_metadata_rational_t>(
89           ANDROID_CONTROL_AE_COMPENSATION_STEP, kAeCompensationUnit)));
90   // TODO(b/31021522): Autofocus subcomponent.
91   components.insert(
92       NoEffectMenuControl<uint8_t>(ANDROID_CONTROL_AF_MODE,
93                                    ANDROID_CONTROL_AF_AVAILABLE_MODES,
94                                    {ANDROID_CONTROL_AF_MODE_OFF}));
95   // TODO(b/31021522): Should read autofocus state from
96   // V4L2_CID_AUTO_FOCUS_STATUS bitmask. The framework gets a little more
97   // complex than that does; there's a whole state-machine table in
98   // the docs (system/media/camera/docs/docs.html).
99   components.insert(FixedState<uint8_t>(ANDROID_CONTROL_AF_STATE,
100                                         ANDROID_CONTROL_AF_STATE_INACTIVE));
101   // TODO(b/31022735): Correctly implement AE & AF triggers that
102   // actually do something. These no effect triggers are even worse than most
103   // of the useless controls in this class, since technically they should
104   // revert back to IDLE eventually after START/CANCEL, but for now they won't
105   // unless IDLE is requested.
106   components.insert(
107       NoEffectMenuControl<uint8_t>(ANDROID_CONTROL_AF_TRIGGER,
108                                    DO_NOT_REPORT_OPTIONS,
109                                    {ANDROID_CONTROL_AF_TRIGGER_IDLE,
110                                     ANDROID_CONTROL_AF_TRIGGER_START,
111                                     ANDROID_CONTROL_AF_TRIGGER_CANCEL}));
112   components.insert(NoEffectMenuControl<uint8_t>(
113       ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER,
114       DO_NOT_REPORT_OPTIONS,
115       {ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_IDLE,
116        ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_START,
117        ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_CANCEL}));
118   components.insert(V4L2ControlOrDefault<uint8_t>(
119       ControlType::kMenu,
120       ANDROID_CONTROL_AE_ANTIBANDING_MODE,
121       ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES,
122       device,
123       V4L2_CID_POWER_LINE_FREQUENCY,
124       std::shared_ptr<ConverterInterface<uint8_t, int32_t>>(
125           new EnumConverter({{V4L2_CID_POWER_LINE_FREQUENCY_DISABLED,
126                               ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF},
127                              {V4L2_CID_POWER_LINE_FREQUENCY_50HZ,
128                               ANDROID_CONTROL_AE_ANTIBANDING_MODE_50HZ},
129                              {V4L2_CID_POWER_LINE_FREQUENCY_60HZ,
130                               ANDROID_CONTROL_AE_ANTIBANDING_MODE_60HZ},
131                              {V4L2_CID_POWER_LINE_FREQUENCY_AUTO,
132                               ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO}})),
133       ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO,
134       {{CAMERA3_TEMPLATE_MANUAL, ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF},
135        {OTHER_TEMPLATES, ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO}}));
136   std::unique_ptr<PartialMetadataInterface> exposure_time =
137       V4L2Control<int64_t>(ControlType::kSlider,
138                            ANDROID_SENSOR_EXPOSURE_TIME,
139                            ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE,
140                            device,
141                            V4L2_CID_EXPOSURE_ABSOLUTE,
142                            std::make_shared<ScalingConverter<int64_t, int32_t>>(
143                                kV4L2ExposureTimeStepNs, 1));
144   // TODO(b/31037072): Sensitivity has additional V4L2 controls
145   // (V4L2_CID_ISO_SENSITIVITY_AUTO), so this control currently has
146   // undefined behavior.
147   // TODO(b/30921166): V4L2_CID_ISO_SENSITIVITY is an int menu, so
148   // this will return nullptr until that is added.
149   std::unique_ptr<PartialMetadataInterface> sensitivity =
150       V4L2Control<int32_t>(ControlType::kSlider,
151                            ANDROID_SENSOR_SENSITIVITY,
152                            ANDROID_SENSOR_INFO_SENSITIVITY_RANGE,
153                            device,
154                            V4L2_CID_ISO_SENSITIVITY,
155                            std::make_shared<ScalingConverter<int32_t, int32_t>>(
156                                1, kV4L2SensitivityDenominator));
157   std::multimap<int32_t, uint8_t> ae_mode_mapping = {
158       {V4L2_EXPOSURE_AUTO, ANDROID_CONTROL_AE_MODE_ON}};
159   if (exposure_time && sensitivity) {
160     // TODO(b/30510395): as part of coordinated 3A component,
161     // if these aren't available don't advertise AE mode OFF, only AUTO.
162     components.insert(std::move(exposure_time));
163     components.insert(std::move(sensitivity));
164     ae_mode_mapping.emplace(V4L2_EXPOSURE_MANUAL, ANDROID_CONTROL_AE_MODE_OFF);
165   }
166   components.insert(V4L2ControlOrDefault<uint8_t>(
167       ControlType::kMenu,
168       ANDROID_CONTROL_AE_MODE,
169       ANDROID_CONTROL_AE_AVAILABLE_MODES,
170       device,
171       V4L2_CID_EXPOSURE_AUTO,
172       std::shared_ptr<ConverterInterface<uint8_t, int32_t>>(
173           new EnumConverter(ae_mode_mapping)),
174       ANDROID_CONTROL_AE_MODE_ON,
175       {{CAMERA3_TEMPLATE_MANUAL, ANDROID_CONTROL_AE_MODE_OFF},
176        {OTHER_TEMPLATES, ANDROID_CONTROL_AE_MODE_ON}}));
177   // Can't get AE status from V4L2.
178   // TODO(b/30510395): If AE mode is OFF, this should switch to INACTIVE.
179   components.insert(FixedState<uint8_t>(ANDROID_CONTROL_AE_STATE,
180                                         ANDROID_CONTROL_AE_STATE_CONVERGED));
181   // V4L2 offers multiple white balance interfaces. Try the advanced one before
182   // falling
183   // back to the simpler version.
184   // Modes from each API that don't match up:
185   // Android: WARM_FLUORESCENT, TWILIGHT.
186   // V4L2: FLUORESCENT_H, HORIZON, FLASH.
187   std::unique_ptr<PartialMetadataInterface> awb(V4L2Control<uint8_t>(
188       ControlType::kMenu,
189       ANDROID_CONTROL_AWB_MODE,
190       ANDROID_CONTROL_AWB_AVAILABLE_MODES,
191       device,
192       V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE,
193       std::shared_ptr<ConverterInterface<uint8_t, int32_t>>(new EnumConverter(
194           {{V4L2_WHITE_BALANCE_MANUAL, ANDROID_CONTROL_AWB_MODE_OFF},
195            {V4L2_WHITE_BALANCE_AUTO, ANDROID_CONTROL_AWB_MODE_AUTO},
196            {V4L2_WHITE_BALANCE_INCANDESCENT,
197             ANDROID_CONTROL_AWB_MODE_INCANDESCENT},
198            {V4L2_WHITE_BALANCE_FLUORESCENT,
199             ANDROID_CONTROL_AWB_MODE_FLUORESCENT},
200            {V4L2_WHITE_BALANCE_DAYLIGHT, ANDROID_CONTROL_AWB_MODE_DAYLIGHT},
201            {V4L2_WHITE_BALANCE_CLOUDY,
202             ANDROID_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT},
203            {V4L2_WHITE_BALANCE_SHADE, ANDROID_CONTROL_AWB_MODE_SHADE}})),
204       {{CAMERA3_TEMPLATE_MANUAL, ANDROID_CONTROL_AWB_MODE_OFF},
205        {OTHER_TEMPLATES, ANDROID_CONTROL_AWB_MODE_AUTO}}));
206   if (awb) {
207     components.insert(std::move(awb));
208   } else {
209     // Fall back to simpler AWB or even just an ignored control.
210     components.insert(V4L2ControlOrDefault<uint8_t>(
211         ControlType::kMenu,
212         ANDROID_CONTROL_AWB_MODE,
213         ANDROID_CONTROL_AWB_AVAILABLE_MODES,
214         device,
215         V4L2_CID_AUTO_WHITE_BALANCE,
216         std::shared_ptr<ConverterInterface<uint8_t, int32_t>>(
217             new EnumConverter({{0, ANDROID_CONTROL_AWB_MODE_OFF},
218                                {1, ANDROID_CONTROL_AWB_MODE_AUTO}})),
219         ANDROID_CONTROL_AWB_MODE_AUTO,
220         {{CAMERA3_TEMPLATE_MANUAL, ANDROID_CONTROL_AWB_MODE_OFF},
221          {OTHER_TEMPLATES, ANDROID_CONTROL_AWB_MODE_AUTO}}));
222   }
223   // TODO(b/31041577): Handle AWB state machine correctly.
224   components.insert(FixedState<uint8_t>(ANDROID_CONTROL_AWB_STATE,
225                                         ANDROID_CONTROL_AWB_STATE_CONVERGED));
226   // TODO(b/31022153): 3A locks.
227   components.insert(std::unique_ptr<PartialMetadataInterface>(
228       new Property<uint8_t>(ANDROID_CONTROL_AE_LOCK_AVAILABLE,
229                             ANDROID_CONTROL_AE_LOCK_AVAILABLE_FALSE)));
230   components.insert(
231       NoEffectMenuControl<uint8_t>(ANDROID_CONTROL_AE_LOCK,
232                                    DO_NOT_REPORT_OPTIONS,
233                                    {ANDROID_CONTROL_AE_LOCK_OFF}));
234   components.insert(std::unique_ptr<PartialMetadataInterface>(
235       new Property<uint8_t>(ANDROID_CONTROL_AWB_LOCK_AVAILABLE,
236                             ANDROID_CONTROL_AWB_LOCK_AVAILABLE_FALSE)));
237   components.insert(
238       NoEffectMenuControl<uint8_t>(ANDROID_CONTROL_AWB_LOCK,
239                                    DO_NOT_REPORT_OPTIONS,
240                                    {ANDROID_CONTROL_AWB_LOCK_OFF}));
241   // TODO(b/30510395): subcomponents of scene modes
242   // (may itself be a subcomponent of 3A).
243   // Modes from each API that don't match up:
244   // Android: FACE_PRIORITY, ACTION, NIGHT_PORTRAIT, THEATRE, STEADYPHOTO,
245   // BARCODE, HIGH_SPEED_VIDEO.
246   // V4L2: BACKLIGHT, DAWN_DUSK, FALL_COLORS, TEXT.
247   components.insert(V4L2ControlOrDefault<uint8_t>(
248       ControlType::kMenu,
249       ANDROID_CONTROL_SCENE_MODE,
250       ANDROID_CONTROL_AVAILABLE_SCENE_MODES,
251       device,
252       V4L2_CID_SCENE_MODE,
253       std::shared_ptr<ConverterInterface<uint8_t, int32_t>>(new EnumConverter(
254           {{V4L2_SCENE_MODE_NONE, ANDROID_CONTROL_SCENE_MODE_DISABLED},
255            {V4L2_SCENE_MODE_BEACH_SNOW, ANDROID_CONTROL_SCENE_MODE_BEACH},
256            {V4L2_SCENE_MODE_BEACH_SNOW, ANDROID_CONTROL_SCENE_MODE_SNOW},
257            {V4L2_SCENE_MODE_CANDLE_LIGHT,
258             ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT},
259            {V4L2_SCENE_MODE_FIREWORKS, ANDROID_CONTROL_SCENE_MODE_FIREWORKS},
260            {V4L2_SCENE_MODE_LANDSCAPE, ANDROID_CONTROL_SCENE_MODE_LANDSCAPE},
261            {V4L2_SCENE_MODE_NIGHT, ANDROID_CONTROL_SCENE_MODE_NIGHT},
262            {V4L2_SCENE_MODE_PARTY_INDOOR, ANDROID_CONTROL_SCENE_MODE_PARTY},
263            {V4L2_SCENE_MODE_SPORTS, ANDROID_CONTROL_SCENE_MODE_SPORTS},
264            {V4L2_SCENE_MODE_SUNSET, ANDROID_CONTROL_SCENE_MODE_SUNSET}})),
265       ANDROID_CONTROL_SCENE_MODE_DISABLED));
266   // TODO(b/31022612): Scene mode overrides.
267   // Modes from each API that don't match up:
268   // Android: POSTERIZE, WHITEBOARD, BLACKBOARD.
269   // V4L2: ANTIQUE, ART_FREEZE, EMBOSS, GRASS_GREEN, SKETCH, SKIN_WHITEN,
270   // SKY_BLUE, SILHOUETTE, VIVID, SET_CBCR.
271   components.insert(V4L2ControlOrDefault<uint8_t>(
272       ControlType::kMenu,
273       ANDROID_CONTROL_EFFECT_MODE,
274       ANDROID_CONTROL_AVAILABLE_EFFECTS,
275       device,
276       V4L2_CID_COLORFX,
277       std::shared_ptr<ConverterInterface<uint8_t, int32_t>>(new EnumConverter(
278           {{V4L2_COLORFX_NONE, ANDROID_CONTROL_EFFECT_MODE_OFF},
279            {V4L2_COLORFX_BW, ANDROID_CONTROL_EFFECT_MODE_MONO},
280            {V4L2_COLORFX_NEGATIVE, ANDROID_CONTROL_EFFECT_MODE_NEGATIVE},
281            {V4L2_COLORFX_SOLARIZATION, ANDROID_CONTROL_EFFECT_MODE_SOLARIZE},
282            {V4L2_COLORFX_SEPIA, ANDROID_CONTROL_EFFECT_MODE_SEPIA},
283            {V4L2_COLORFX_AQUA, ANDROID_CONTROL_EFFECT_MODE_AQUA}})),
284       ANDROID_CONTROL_EFFECT_MODE_OFF));
285   // TODO(b/31021654): This should behave as a top level switch, not no effect.
286   // Should enforce being set to USE_SCENE_MODE when a scene mode is requested.
287   components.insert(NoEffectMenuControl<uint8_t>(
288       ANDROID_CONTROL_MODE,
289       ANDROID_CONTROL_AVAILABLE_MODES,
290       {ANDROID_CONTROL_MODE_AUTO, ANDROID_CONTROL_MODE_USE_SCENE_MODE}));
291 
292   // Not sure if V4L2 does or doesn't do this, but HAL documentation says
293   // all devices must support FAST, and FAST can be equivalent to OFF, so
294   // either way it's fine to list. And if FAST is included, HIGH_QUALITY
295   // is supposed to be included as well.
296   components.insert(NoEffectMenuControl<uint8_t>(
297       ANDROID_EDGE_MODE,
298       ANDROID_EDGE_AVAILABLE_EDGE_MODES,
299       {ANDROID_EDGE_MODE_FAST, ANDROID_EDGE_MODE_HIGH_QUALITY},
300       {{CAMERA3_TEMPLATE_STILL_CAPTURE, ANDROID_EDGE_MODE_HIGH_QUALITY},
301        {OTHER_TEMPLATES, ANDROID_EDGE_MODE_FAST}}));
302 
303   // TODO(b/31023454): subcomponents of flash.
304   components.insert(
305       std::unique_ptr<PartialMetadataInterface>(new Property<uint8_t>(
306           ANDROID_FLASH_INFO_AVAILABLE, ANDROID_FLASH_INFO_AVAILABLE_FALSE)));
307   components.insert(FixedState<uint8_t>(ANDROID_FLASH_STATE,
308                                         ANDROID_FLASH_STATE_UNAVAILABLE));
309   components.insert(NoEffectMenuControl<uint8_t>(
310       ANDROID_FLASH_MODE, DO_NOT_REPORT_OPTIONS, {ANDROID_FLASH_MODE_OFF}));
311 
312   // TODO(30510395): subcomponents of hotpixel.
313   // No known V4L2 hot pixel correction. But it might be happening,
314   // so we report FAST/HIGH_QUALITY.
315   components.insert(NoEffectMenuControl<uint8_t>(
316       ANDROID_HOT_PIXEL_MODE,
317       ANDROID_HOT_PIXEL_AVAILABLE_HOT_PIXEL_MODES,
318       {ANDROID_HOT_PIXEL_MODE_FAST, ANDROID_HOT_PIXEL_MODE_HIGH_QUALITY}));
319   // ON only needs to be supported for RAW capable devices.
320   components.insert(NoEffectMenuControl<uint8_t>(
321       ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE,
322       ANDROID_STATISTICS_INFO_AVAILABLE_HOT_PIXEL_MAP_MODES,
323       {ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE_OFF}));
324 
325   // TODO(30510395): subcomponents focus/lens.
326   // No way to actually get the aperture and focal length
327   // in V4L2, but they're required keys, so fake them.
328   components.insert(
329       NoEffectMenuControl<float>(ANDROID_LENS_APERTURE,
330                                  ANDROID_LENS_INFO_AVAILABLE_APERTURES,
331                                  {2.0}));  // RPi camera v2 is f/2.0.
332   // Always assume external-facing.
333   components.insert(
334       std::unique_ptr<PartialMetadataInterface>(new Property<uint8_t>(
335           ANDROID_LENS_FACING, ANDROID_LENS_FACING_EXTERNAL)));
336   components.insert(
337       NoEffectMenuControl<float>(ANDROID_LENS_FOCAL_LENGTH,
338                                  ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS,
339                                  {3.04}));  // RPi camera v2 is 3.04mm.
340   // No known way to get filter densities from V4L2,
341   // report 0 to indicate this control is not supported.
342   components.insert(
343       NoEffectMenuControl<float>(ANDROID_LENS_FILTER_DENSITY,
344                                  ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES,
345                                  {0.0}));
346   // V4L2 focal units do not correspond to a particular physical unit.
347   components.insert(
348       std::unique_ptr<PartialMetadataInterface>(new Property<uint8_t>(
349           ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION,
350           ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION_UNCALIBRATED)));
351   // TODO(b/31022711): Focus distance component.
352   // Using a NoEffectMenuControl for now because for
353   // fixed-focus it meets expectations. Framework may allow
354   // setting any value and expect it to be clamped to 0, in which
355   // case this will have unexpected behavior (failing on non-0 settings).
356   components.insert(
357       NoEffectMenuControl<float>(ANDROID_LENS_FOCUS_DISTANCE,
358                                  ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE,
359                                  {0}));
360   // Hypefocal distance doesn't mean much for a fixed-focus uncalibrated device.
361   components.insert(std::make_unique<Property<float>>(
362       ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE, 0));
363 
364   // No way to know when the lens is moving or not in V4L2.
365   components.insert(
366       FixedState<uint8_t>(ANDROID_LENS_STATE, ANDROID_LENS_STATE_STATIONARY));
367   // No known V4L2 lens shading. But it might be happening,
368   // so report FAST/HIGH_QUALITY.
369   components.insert(NoEffectMenuControl<uint8_t>(
370       ANDROID_SHADING_MODE,
371       ANDROID_SHADING_AVAILABLE_MODES,
372       {ANDROID_SHADING_MODE_FAST, ANDROID_SHADING_MODE_HIGH_QUALITY}));
373   // ON only needs to be supported for RAW capable devices.
374   components.insert(NoEffectMenuControl<uint8_t>(
375       ANDROID_STATISTICS_LENS_SHADING_MAP_MODE,
376       ANDROID_STATISTICS_INFO_AVAILABLE_LENS_SHADING_MAP_MODES,
377       {ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_OFF}));
378   // V4L2 doesn't differentiate between OPTICAL and VIDEO stabilization,
379   // so only report one (and report the other as OFF).
380   components.insert(V4L2ControlOrDefault<uint8_t>(
381       ControlType::kMenu,
382       ANDROID_CONTROL_VIDEO_STABILIZATION_MODE,
383       ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES,
384       device,
385       V4L2_CID_IMAGE_STABILIZATION,
386       std::shared_ptr<ConverterInterface<uint8_t, int32_t>>(new EnumConverter(
387           {{0, ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF},
388            {1, ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_ON}})),
389       ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF));
390   components.insert(NoEffectMenuControl<uint8_t>(
391       ANDROID_LENS_OPTICAL_STABILIZATION_MODE,
392       ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION,
393       {ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF}));
394   // TODO(b/31017806): This should definitely have a different default depending
395   // on template.
396   components.insert(NoEffectMenuControl<uint8_t>(
397       ANDROID_CONTROL_CAPTURE_INTENT,
398       DO_NOT_REPORT_OPTIONS,
399       {ANDROID_CONTROL_CAPTURE_INTENT_CUSTOM,
400        ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW,
401        ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE,
402        ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_RECORD,
403        ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT,
404        ANDROID_CONTROL_CAPTURE_INTENT_ZERO_SHUTTER_LAG,
405        ANDROID_CONTROL_CAPTURE_INTENT_MANUAL},
406       {{CAMERA3_TEMPLATE_PREVIEW, ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW},
407        {CAMERA3_TEMPLATE_STILL_CAPTURE,
408         ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE},
409        {CAMERA3_TEMPLATE_VIDEO_RECORD,
410         ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_RECORD},
411        {CAMERA3_TEMPLATE_VIDEO_SNAPSHOT,
412         ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT},
413        {CAMERA3_TEMPLATE_ZERO_SHUTTER_LAG,
414         ANDROID_CONTROL_CAPTURE_INTENT_ZERO_SHUTTER_LAG},
415        {CAMERA3_TEMPLATE_MANUAL, ANDROID_CONTROL_CAPTURE_INTENT_MANUAL},
416        {OTHER_TEMPLATES, ANDROID_CONTROL_CAPTURE_INTENT_CUSTOM}}));
417 
418   // Unable to control noise reduction in V4L2 devices,
419   // but FAST is allowed to be the same as OFF,
420   // and HIGH_QUALITY can be the same as FAST.
421   components.insert(NoEffectMenuControl<uint8_t>(
422       ANDROID_NOISE_REDUCTION_MODE,
423       ANDROID_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES,
424       {ANDROID_NOISE_REDUCTION_MODE_FAST,
425        ANDROID_NOISE_REDUCTION_MODE_HIGH_QUALITY},
426       {{CAMERA3_TEMPLATE_STILL_CAPTURE,
427         ANDROID_NOISE_REDUCTION_MODE_HIGH_QUALITY},
428        {OTHER_TEMPLATES, ANDROID_NOISE_REDUCTION_MODE_FAST}}));
429 
430   // TODO(30510395): subcomponents of formats/streams.
431   // For now, no thumbnails available (only [0,0], the "no thumbnail" size).
432   // TODO(b/29580107): Could end up with a mismatch between request & result,
433   // since V4L2 doesn't actually allow for thumbnail size control.
434   components.insert(NoEffectMenuControl<std::array<int32_t, 2>>(
435       ANDROID_JPEG_THUMBNAIL_SIZE,
436       ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES,
437       {{{0, 0}}}));
438   // TODO(b/31022752): Get this from the device, not constant.
439   components.insert(std::unique_ptr<PartialMetadataInterface>(
440       new Property<int32_t>(ANDROID_JPEG_MAX_SIZE, kV4L2MaxJpegSize)));
441   // TODO(b/31021672): Other JPEG controls (GPS, quality, orientation).
442   // TODO(b/29939583): V4L2 can only support 1 stream at a time.
443   // For now, just reporting minimum allowable for LIMITED devices.
444   components.insert(std::unique_ptr<PartialMetadataInterface>(
445       new Property<std::array<int32_t, 3>>(
446           ANDROID_REQUEST_MAX_NUM_OUTPUT_STREAMS,
447           {{/* Raw */ 0, /* Non-stalling */ 2, /* Stalling */ 1}})));
448   // Reprocessing not supported.
449   components.insert(std::unique_ptr<PartialMetadataInterface>(
450       new Property<int32_t>(ANDROID_REQUEST_MAX_NUM_INPUT_STREAMS, 0)));
451   // No way to know pipeline depth for V4L2, so fake with max allowable latency.
452   // Doesn't mean much without per-frame controls anyways.
453   components.insert(std::unique_ptr<PartialMetadataInterface>(
454       new Property<uint8_t>(ANDROID_REQUEST_PIPELINE_MAX_DEPTH, 4)));
455   components.insert(FixedState<uint8_t>(ANDROID_REQUEST_PIPELINE_DEPTH, 4));
456   // "LIMITED devices are strongly encouraged to use a non-negative value.
457   // If UNKNOWN is used here then app developers do not have a way to know
458   // when sensor settings have been applied." - Unfortunately, V4L2 doesn't
459   // really help here either. Could even be that adjusting settings mid-stream
460   // blocks in V4L2, and should be avoided.
461   components.insert(
462       std::unique_ptr<PartialMetadataInterface>(new Property<int32_t>(
463           ANDROID_SYNC_MAX_LATENCY, ANDROID_SYNC_MAX_LATENCY_UNKNOWN)));
464   // Never know when controls are synced.
465   components.insert(FixedState<int64_t>(ANDROID_SYNC_FRAME_NUMBER,
466                                         ANDROID_SYNC_FRAME_NUMBER_UNKNOWN));
467 
468   // TODO(b/31022480): subcomponents of cropping/sensors.
469   // Need ANDROID_SCALER_CROP_REGION control support.
470   // V4L2 VIDIOC_CROPCAP doesn't give a way to query this;
471   // it's driver dependent. For now, assume freeform, and
472   // some cameras may just behave badly.
473   // TODO(b/29579652): Figure out a way to determine this.
474   components.insert(std::unique_ptr<PartialMetadataInterface>(
475       new Property<float>(ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM, 1)));
476   components.insert(std::unique_ptr<PartialMetadataInterface>(
477       new Property<uint8_t>(ANDROID_SCALER_CROPPING_TYPE,
478                             ANDROID_SCALER_CROPPING_TYPE_FREEFORM)));
479   // Spoof pixel array size for now, eventually get from CROPCAP.
480   std::array<int32_t, 2> pixel_array_size = {{3280, 2464}};
481   components.insert(std::unique_ptr<PartialMetadataInterface>(
482       new Property<std::array<int32_t, 2>>(ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE,
483                                            pixel_array_size)));
484   // Active array size is {x-offset, y-offset, width, height}, relative to
485   // the pixel array size, with {0, 0} being the top left. Since there's no way
486   // to get this in V4L2, assume the full pixel array is the active array.
487   std::array<int32_t, 4> active_array_size = {
488       {0, 0, pixel_array_size[0], pixel_array_size[1]}};
489   components.insert(std::unique_ptr<PartialMetadataInterface>(
490       new Property<std::array<int32_t, 4>>(
491           ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE, active_array_size)));
492   // This is really more freeform than a menu control, but since we're
493   // restricting it to not being used anyways this works for now.
494   components.insert(NoEffectMenuControl<std::array<int32_t, 4>>(
495       ANDROID_SCALER_CROP_REGION, DO_NOT_REPORT_OPTIONS, {active_array_size}));
496   // No way to get in V4L2, so faked. RPi camera v2 is 3.674 x 2.760 mm.
497   // Physical size is used in framework calculations (field of view,
498   // pixel pitch, etc.), so faking it may have unexpected results.
499   components.insert(std::unique_ptr<PartialMetadataInterface>(
500       new Property<std::array<float, 2>>(ANDROID_SENSOR_INFO_PHYSICAL_SIZE,
501                                          {{3.674, 2.760}})));
502   // HAL uses BOOTTIME timestamps.
503   // TODO(b/29457051): make sure timestamps are consistent throughout the HAL.
504   components.insert(std::unique_ptr<PartialMetadataInterface>(
505       new Property<uint8_t>(ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE,
506                             ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE_UNKNOWN)));
507   components.insert(std::make_unique<State<int64_t>>(
508       ANDROID_SENSOR_TIMESTAMP, std::make_unique<BoottimeStateDelegate>()));
509   // No way to actually get shutter skew from V4L2.
510   components.insert(
511       FixedState<int64_t>(ANDROID_SENSOR_ROLLING_SHUTTER_SKEW, 0));
512   // No way to actually get orientation from V4L2.
513   components.insert(std::unique_ptr<PartialMetadataInterface>(
514       new Property<int32_t>(ANDROID_SENSOR_ORIENTATION, 0)));
515   // TODO(b/31023611): Sensor frame duration. Range should
516   // be dependent on the stream configuration being used.
517   // No test patterns supported.
518   components.insert(
519       NoEffectMenuControl<int32_t>(ANDROID_SENSOR_TEST_PATTERN_MODE,
520                                    ANDROID_SENSOR_AVAILABLE_TEST_PATTERN_MODES,
521                                    {ANDROID_SENSOR_TEST_PATTERN_MODE_OFF}));
522 
523   // TODO(b/30510395): subcomponents of face detection.
524   // Face detection not supported.
525   components.insert(NoEffectMenuControl<uint8_t>(
526       ANDROID_STATISTICS_FACE_DETECT_MODE,
527       ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES,
528       {ANDROID_STATISTICS_FACE_DETECT_MODE_OFF}));
529   components.insert(std::unique_ptr<PartialMetadataInterface>(
530       new Property<int32_t>(ANDROID_STATISTICS_INFO_MAX_FACE_COUNT, 0)));
531 
532   // No way to get detected scene flicker from V4L2.
533   components.insert(FixedState<uint8_t>(ANDROID_STATISTICS_SCENE_FLICKER,
534                                         ANDROID_STATISTICS_SCENE_FLICKER_NONE));
535 
536   // TOOD(b/31023265): V4L2_CID_FLASH_INDICATOR_INTENSITY could be queried
537   // to see if there's a transmit LED. Would need to translate HAL off/on
538   // enum to slider min/max value. For now, no LEDs available.
539   components.insert(std::unique_ptr<PartialMetadataInterface>(
540       new Property<uint8_t>(ANDROID_LED_AVAILABLE_LEDS, {})));
541 
542   /* Capabilities. */
543   // The V4L2Metadata pretends to at least meet the
544   // "LIMITED" and "BACKWARD_COMPATIBLE" functionality requirements.
545   components.insert(std::unique_ptr<PartialMetadataInterface>(
546       new Property<uint8_t>(ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL,
547                             ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED)));
548   components.insert(std::unique_ptr<PartialMetadataInterface>(
549       new Property<std::vector<uint8_t>>(
550           ANDROID_REQUEST_AVAILABLE_CAPABILITIES,
551           {ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE})));
552 
553   // Request is unused, and can be any value,
554   // but that value needs to be propagated.
555   components.insert(NoEffectOptionlessControl<int32_t>(ANDROID_REQUEST_ID, 0));
556 
557   // Metadata is returned in a single result; not multiple pieces.
558   components.insert(std::make_unique<Property<int32_t>>(
559       ANDROID_REQUEST_PARTIAL_RESULT_COUNT, 1));
560 
561   int res =
562       AddFormatComponents(device, std::inserter(components, components.end()));
563   if (res) {
564     HAL_LOGE("Failed to initialize format components.");
565     return res;
566   }
567 
568   *result = std::make_unique<Metadata>(std::move(components));
569   return 0;
570 }
571 
572 }  // namespace v4l2_camera_hal
573