am 344fd20d: (-s ours) Camera: Metadata docs HTML generated from XML: DO NOT MERGE
# Via Igor Murashkin
* commit '344fd20d2cd4902fe4dbdf5c3192ed8ab162eca2':
Camera: Metadata docs HTML generated from XML: DO NOT MERGE
diff --git a/audio_effects/include/audio_effects/effect_bassboost.h b/audio_effects/include/audio_effects/effect_bassboost.h
index cf9375e..3735904 100644
--- a/audio_effects/include/audio_effects/effect_bassboost.h
+++ b/audio_effects/include/audio_effects/effect_bassboost.h
@@ -24,7 +24,8 @@
#endif
#ifndef OPENSL_ES_H_
-static const effect_uuid_t SL_IID_BASSBOOST_ = { 0x0634f220, 0xddd4, 0x11db, 0xa0fc, { 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b } };
+static const effect_uuid_t SL_IID_BASSBOOST_ = { 0x0634f220, 0xddd4, 0x11db, 0xa0fc,
+ { 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b } };
const effect_uuid_t * const SL_IID_BASSBOOST = &SL_IID_BASSBOOST_;
#endif //OPENSL_ES_H_
diff --git a/audio_effects/include/audio_effects/effect_environmentalreverb.h b/audio_effects/include/audio_effects/effect_environmentalreverb.h
index 77f3697..3acbd5c 100644
--- a/audio_effects/include/audio_effects/effect_environmentalreverb.h
+++ b/audio_effects/include/audio_effects/effect_environmentalreverb.h
@@ -24,7 +24,8 @@
#endif
#ifndef OPENSL_ES_H_
-static const effect_uuid_t SL_IID_ENVIRONMENTALREVERB_ = { 0xc2e5d5f0, 0x94bd, 0x4763, 0x9cac, { 0x4e, 0x23, 0x4d, 0x6, 0x83, 0x9e } };
+static const effect_uuid_t SL_IID_ENVIRONMENTALREVERB_ = { 0xc2e5d5f0, 0x94bd, 0x4763, 0x9cac,
+ { 0x4e, 0x23, 0x4d, 0x6, 0x83, 0x9e } };
const effect_uuid_t * const SL_IID_ENVIRONMENTALREVERB = &SL_IID_ENVIRONMENTALREVERB_;
#endif //OPENSL_ES_H_
diff --git a/audio_effects/include/audio_effects/effect_equalizer.h b/audio_effects/include/audio_effects/effect_equalizer.h
index e0c3bbd..17ee74f 100644
--- a/audio_effects/include/audio_effects/effect_equalizer.h
+++ b/audio_effects/include/audio_effects/effect_equalizer.h
@@ -20,7 +20,8 @@
#include <hardware/audio_effect.h>
#ifndef OPENSL_ES_H_
-static const effect_uuid_t SL_IID_EQUALIZER_ = { 0x0bed4300, 0xddd6, 0x11db, 0x8f34, { 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b } };
+static const effect_uuid_t SL_IID_EQUALIZER_ = { 0x0bed4300, 0xddd6, 0x11db, 0x8f34,
+ { 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b } };
const effect_uuid_t * const SL_IID_EQUALIZER = &SL_IID_EQUALIZER_;
#endif //OPENSL_ES_H_
@@ -31,12 +32,14 @@
/* enumerated parameters for Equalizer effect */
typedef enum
{
- EQ_PARAM_NUM_BANDS, // Gets the number of frequency bands that the equalizer supports.
+ EQ_PARAM_NUM_BANDS, // Gets the number of frequency bands that the equalizer
+ // supports.
EQ_PARAM_LEVEL_RANGE, // Returns the minimum and maximum band levels supported.
EQ_PARAM_BAND_LEVEL, // Gets/Sets the gain set for the given equalizer band.
EQ_PARAM_CENTER_FREQ, // Gets the center frequency of the given band.
EQ_PARAM_BAND_FREQ_RANGE, // Gets the frequency range of the given frequency band.
- EQ_PARAM_GET_BAND, // Gets the band that has the most effect on the given frequency.
+ EQ_PARAM_GET_BAND, // Gets the band that has the most effect on the given
+ // frequency.
EQ_PARAM_CUR_PRESET, // Gets/Sets the current preset.
EQ_PARAM_GET_NUM_OF_PRESETS, // Gets the total number of presets the equalizer supports.
EQ_PARAM_GET_PRESET_NAME, // Gets the preset name based on the index.
diff --git a/audio_effects/include/audio_effects/effect_presetreverb.h b/audio_effects/include/audio_effects/effect_presetreverb.h
index e8d6052..ba1beae 100644
--- a/audio_effects/include/audio_effects/effect_presetreverb.h
+++ b/audio_effects/include/audio_effects/effect_presetreverb.h
@@ -24,7 +24,8 @@
#endif
#ifndef OPENSL_ES_H_
-static const effect_uuid_t SL_IID_PRESETREVERB_ = { 0x47382d60, 0xddd8, 0x11db, 0xbf3a, { 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b } };
+static const effect_uuid_t SL_IID_PRESETREVERB_ = { 0x47382d60, 0xddd8, 0x11db, 0xbf3a,
+ { 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b } };
const effect_uuid_t * const SL_IID_PRESETREVERB = &SL_IID_PRESETREVERB_;
#endif //OPENSL_ES_H_
diff --git a/audio_effects/include/audio_effects/effect_virtualizer.h b/audio_effects/include/audio_effects/effect_virtualizer.h
index a6f6fa2..fdb68a9 100644
--- a/audio_effects/include/audio_effects/effect_virtualizer.h
+++ b/audio_effects/include/audio_effects/effect_virtualizer.h
@@ -24,7 +24,8 @@
#endif
#ifndef OPENSL_ES_H_
-static const effect_uuid_t SL_IID_VIRTUALIZER_ = { 0x37cc2c00, 0xdddd, 0x11db, 0x8577, { 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b } };
+static const effect_uuid_t SL_IID_VIRTUALIZER_ = { 0x37cc2c00, 0xdddd, 0x11db, 0x8577,
+ { 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b } };
const effect_uuid_t * const SL_IID_VIRTUALIZER = &SL_IID_VIRTUALIZER_;
#endif //OPENSL_ES_H_
diff --git a/audio_route/Android.mk b/audio_route/Android.mk
new file mode 100644
index 0000000..7470dc6
--- /dev/null
+++ b/audio_route/Android.mk
@@ -0,0 +1,12 @@
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+LOCAL_C_INCLUDES += \
+ external/tinyalsa/include \
+ external/expat/lib
+LOCAL_SRC_FILES:= audio_route.c
+LOCAL_MODULE := libaudioroute
+LOCAL_SHARED_LIBRARIES:= liblog libcutils libutils libexpat libtinyalsa
+LOCAL_MODULE_TAGS := optional
+LOCAL_PRELINK_MODULE := false
+include $(BUILD_SHARED_LIBRARY)
diff --git a/audio_route/MODULE_LICENSE_BSD b/audio_route/MODULE_LICENSE_BSD
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/audio_route/MODULE_LICENSE_BSD
diff --git a/audio_route/NOTICE b/audio_route/NOTICE
new file mode 100644
index 0000000..91b6565
--- /dev/null
+++ b/audio_route/NOTICE
@@ -0,0 +1,25 @@
+Copyright 2013, The Android Open Source Project
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+ * Neither the name of The Android Open Source Project nor the names of
+ its contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY The Android Open Source Project ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL The Android Open Source Project BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGE.
+
diff --git a/audio_route/audio_route.c b/audio_route/audio_route.c
new file mode 100644
index 0000000..ae6c7f7
--- /dev/null
+++ b/audio_route/audio_route.c
@@ -0,0 +1,707 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ * Inspired by TinyHW, written by Mark Brown at Wolfson Micro
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "audio_route"
+/*#define LOG_NDEBUG 0*/
+
+#include <errno.h>
+#include <expat.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <cutils/log.h>
+
+#include <tinyalsa/asoundlib.h>
+
+#define BUF_SIZE 1024
+#define MIXER_XML_PATH "/system/etc/mixer_paths.xml"
+#define INITIAL_MIXER_PATH_SIZE 8
+
+struct mixer_state {
+ struct mixer_ctl *ctl;
+ unsigned int num_values;
+ int *old_value;
+ int *new_value;
+ int *reset_value;
+ /* If linked is true, only the first element in each array is valid */
+ bool old_linked;
+ bool new_linked;
+ bool reset_linked;
+};
+
+struct mixer_setting {
+ struct mixer_ctl *ctl;
+ unsigned int num_values;
+ int *value;
+ /* If linked is true, only the first element in each array is valid */
+ bool linked;
+};
+
+struct mixer_value {
+ struct mixer_ctl *ctl;
+ int index;
+ int value;
+};
+
+struct mixer_path {
+ char *name;
+ unsigned int size;
+ unsigned int length;
+ struct mixer_setting *setting;
+};
+
+struct audio_route {
+ struct mixer *mixer;
+ unsigned int num_mixer_ctls;
+ struct mixer_state *mixer_state;
+
+ unsigned int mixer_path_size;
+ unsigned int num_mixer_paths;
+ struct mixer_path *mixer_path;
+};
+
+struct config_parse_state {
+ struct audio_route *ar;
+ struct mixer_path *path;
+ int level;
+};
+
+/* path functions */
+
+static void path_print(struct mixer_path *path)
+{
+ unsigned int i;
+ unsigned int j;
+
+ ALOGE("Path: %s, length: %d", path->name, path->length);
+ for (i = 0; i < path->length; i++) {
+ ALOGE(" id=%d: ctl=%s linked=%c", i,
+ mixer_ctl_get_name(path->setting[i].ctl),
+ path->setting[i].linked ? 'y' : 'n');
+ for (j = 0; j < path->setting[i].num_values; j++)
+ ALOGE(" id=%d value=%d", j, path->setting[i].value[j]);
+ }
+}
+
+static void path_free(struct audio_route *ar)
+{
+ unsigned int i;
+
+ for (i = 0; i < ar->num_mixer_paths; i++) {
+ if (ar->mixer_path[i].name)
+ free(ar->mixer_path[i].name);
+ if (ar->mixer_path[i].setting) {
+ if (ar->mixer_path[i].setting->value)
+ free(ar->mixer_path[i].setting->value);
+ free(ar->mixer_path[i].setting);
+ }
+ }
+ free(ar->mixer_path);
+}
+
+static struct mixer_path *path_get_by_name(struct audio_route *ar,
+ const char *name)
+{
+ unsigned int i;
+
+ for (i = 0; i < ar->num_mixer_paths; i++)
+ if (strcmp(ar->mixer_path[i].name, name) == 0)
+ return &ar->mixer_path[i];
+
+ return NULL;
+}
+
+static struct mixer_path *path_create(struct audio_route *ar, const char *name)
+{
+ struct mixer_path *new_mixer_path = NULL;
+
+ if (path_get_by_name(ar, name)) {
+ ALOGE("Path name '%s' already exists", name);
+ return NULL;
+ }
+
+ /* check if we need to allocate more space for mixer paths */
+ if (ar->mixer_path_size <= ar->num_mixer_paths) {
+ if (ar->mixer_path_size == 0)
+ ar->mixer_path_size = INITIAL_MIXER_PATH_SIZE;
+ else
+ ar->mixer_path_size *= 2;
+
+ new_mixer_path = realloc(ar->mixer_path, ar->mixer_path_size *
+ sizeof(struct mixer_path));
+ if (new_mixer_path == NULL) {
+ ALOGE("Unable to allocate more paths");
+ return NULL;
+ } else {
+ ar->mixer_path = new_mixer_path;
+ }
+ }
+
+ /* initialise the new mixer path */
+ ar->mixer_path[ar->num_mixer_paths].name = strdup(name);
+ ar->mixer_path[ar->num_mixer_paths].size = 0;
+ ar->mixer_path[ar->num_mixer_paths].length = 0;
+ ar->mixer_path[ar->num_mixer_paths].setting = NULL;
+
+ /* return the mixer path just added, then increment number of them */
+ return &ar->mixer_path[ar->num_mixer_paths++];
+}
+
+static int find_ctl_in_path(struct mixer_path *path, struct mixer_ctl *ctl)
+{
+ unsigned int i;
+
+ for (i = 0; i < path->length; i++)
+ if (path->setting[i].ctl == ctl)
+ return i;
+
+ return -1;
+}
+
+static int alloc_path_setting(struct mixer_path *path)
+{
+ struct mixer_setting *new_path_setting;
+ int path_index;
+
+ /* check if we need to allocate more space for path settings */
+ if (path->size <= path->length) {
+ if (path->size == 0)
+ path->size = INITIAL_MIXER_PATH_SIZE;
+ else
+ path->size *= 2;
+
+ new_path_setting = realloc(path->setting,
+ path->size * sizeof(struct mixer_setting));
+ if (new_path_setting == NULL) {
+ ALOGE("Unable to allocate more path settings");
+ return -1;
+ } else {
+ path->setting = new_path_setting;
+ }
+ }
+
+ path_index = path->length;
+ path->length++;
+
+ return path_index;
+}
+
+static int path_add_setting(struct mixer_path *path,
+ struct mixer_setting *setting)
+{
+ unsigned int i;
+ int path_index;
+
+ if (find_ctl_in_path(path, setting->ctl) != -1) {
+ ALOGE("Control '%s' already exists in path '%s'",
+ mixer_ctl_get_name(setting->ctl), path->name);
+ return -1;
+ }
+
+ path_index = alloc_path_setting(path);
+ if (path_index < 0)
+ return -1;
+
+ path->setting[path_index].ctl = setting->ctl;
+ path->setting[path_index].num_values = setting->num_values;
+ path->setting[path_index].value = malloc(setting->num_values * sizeof(int));
+ path->setting[path_index].linked = setting->linked;
+ if (setting->linked) {
+ path->setting[path_index].value[0] = setting->value[0];
+ } else {
+ for (i = 0; i < setting->num_values; i++)
+ path->setting[path_index].value[i] = setting->value[i];
+ }
+
+ return 0;
+}
+
+static int path_add_value(struct mixer_path *path,
+ struct mixer_value *mixer_value)
+{
+ unsigned int i;
+ int path_index;
+ unsigned int num_values;
+
+ /* Check that mixer value index is within range */
+ num_values = mixer_ctl_get_num_values(mixer_value->ctl);
+ if (mixer_value->index >= (int)num_values) {
+ ALOGE("mixer index %d is out of range for '%s'", mixer_value->index,
+ mixer_ctl_get_name(mixer_value->ctl));
+ return -1;
+ }
+
+ path_index = find_ctl_in_path(path, mixer_value->ctl);
+ if (path_index < 0) {
+ /* New path */
+
+ path_index = alloc_path_setting(path);
+ if (path_index < 0)
+ return -1;
+
+ /* initialise the new path setting */
+ path->setting[path_index].ctl = mixer_value->ctl;
+ path->setting[path_index].num_values = num_values;
+ path->setting[path_index].value = malloc(num_values * sizeof(int));
+ path->setting[path_index].linked = true;
+ path->setting[path_index].value[0] = mixer_value->value;
+ }
+
+ if (mixer_value->index == -1) {
+ /* Linked, so only set the first value */
+ path->setting[path_index].linked = true;
+ path->setting[path_index].value[0] = mixer_value->value;
+ } else {
+ if (path->setting[path_index].linked && (num_values > 1)) {
+ /* Unlinking the values, so duplicate them across */
+ for (i = 1; i < num_values; i++) {
+ path->setting[path_index].value[i] =
+ path->setting[path_index].value[0];
+ }
+ path->setting[path_index].linked = false;
+ }
+ path->setting[path_index].value[mixer_value->index] = mixer_value->value;
+ }
+
+ return 0;
+}
+
+static int path_add_path(struct mixer_path *path, struct mixer_path *sub_path)
+{
+ unsigned int i;
+
+ for (i = 0; i < sub_path->length; i++)
+ if (path_add_setting(path, &sub_path->setting[i]) < 0)
+ return -1;
+
+ return 0;
+}
+
+static int path_apply(struct audio_route *ar, struct mixer_path *path)
+{
+ unsigned int i;
+ unsigned int j;
+ unsigned int ctl_index;
+
+ for (i = 0; i < path->length; i++) {
+ struct mixer_ctl *ctl = path->setting[i].ctl;
+
+ /* locate the mixer ctl in the list */
+ for (ctl_index = 0; ctl_index < ar->num_mixer_ctls; ctl_index++)
+ if (ar->mixer_state[ctl_index].ctl == ctl)
+ break;
+
+ /* apply the new value(s) */
+ for (j = 0; j < ar->mixer_state[ctl_index].num_values; j++) {
+ ar->mixer_state[ctl_index].new_value[j] = path->setting[i].value[j];
+ if (path->setting[i].linked)
+ break;
+ }
+ ar->mixer_state[ctl_index].new_linked = path->setting[i].linked;
+ }
+
+ return 0;
+}
+
+/* mixer helper function */
+static int mixer_enum_string_to_value(struct mixer_ctl *ctl, const char *string)
+{
+ unsigned int i;
+
+ /* Search the enum strings for a particular one */
+ for (i = 0; i < mixer_ctl_get_num_enums(ctl); i++) {
+ if (strcmp(mixer_ctl_get_enum_string(ctl, i), string) == 0)
+ break;
+ }
+
+ return i;
+}
+
+static void start_tag(void *data, const XML_Char *tag_name,
+ const XML_Char **attr)
+{
+ const XML_Char *attr_name = NULL;
+ const XML_Char *attr_id = NULL;
+ const XML_Char *attr_value = NULL;
+ struct config_parse_state *state = data;
+ struct audio_route *ar = state->ar;
+ unsigned int i;
+ unsigned int ctl_index;
+ struct mixer_ctl *ctl;
+ int value;
+ unsigned int id;
+ struct mixer_value mixer_value;
+
+ /* Get name, id and value attributes (these may be empty) */
+ for (i = 0; attr[i]; i += 2) {
+ if (strcmp(attr[i], "name") == 0)
+ attr_name = attr[i + 1];
+ if (strcmp(attr[i], "id") == 0)
+ attr_id = attr[i + 1];
+ else if (strcmp(attr[i], "value") == 0)
+ attr_value = attr[i + 1];
+ }
+
+ /* Look at tags */
+ if (strcmp(tag_name, "path") == 0) {
+ if (attr_name == NULL) {
+ ALOGE("Unnamed path!");
+ } else {
+ if (state->level == 1) {
+ /* top level path: create and stash the path */
+ state->path = path_create(ar, (char *)attr_name);
+ } else {
+ /* nested path */
+ struct mixer_path *sub_path = path_get_by_name(ar, attr_name);
+ path_add_path(state->path, sub_path);
+ }
+ }
+ }
+
+ else if (strcmp(tag_name, "ctl") == 0) {
+ /* Obtain the mixer ctl and value */
+ ctl = mixer_get_ctl_by_name(ar->mixer, attr_name);
+ switch (mixer_ctl_get_type(ctl)) {
+ case MIXER_CTL_TYPE_BOOL:
+ case MIXER_CTL_TYPE_INT:
+ value = atoi((char *)attr_value);
+ break;
+ case MIXER_CTL_TYPE_ENUM:
+ value = mixer_enum_string_to_value(ctl, (char *)attr_value);
+ break;
+ default:
+ value = 0;
+ break;
+ }
+
+ if (state->level == 1) {
+ /* top level ctl (initial setting) */
+
+ /* locate the mixer ctl in the list */
+ for (ctl_index = 0; ctl_index < ar->num_mixer_ctls; ctl_index++) {
+ if (ar->mixer_state[ctl_index].ctl == ctl)
+ break;
+ }
+
+ /* apply the new value */
+ if (attr_id) {
+ /* set only one value */
+ id = atoi((char *)attr_id);
+ if (id < ar->mixer_state[ctl_index].num_values) {
+ if (ar->mixer_state[ctl_index].new_linked) {
+ /*
+ * We're unlinking the values, so copy old_value[0] into
+ * all the new_value elements.
+ */
+ for (i = 0; i < ar->mixer_state[ctl_index].num_values; i++) {
+ ar->mixer_state[ctl_index].new_value[i] =
+ ar->mixer_state[ctl_index].old_value[0];
+ }
+ ar->mixer_state[ctl_index].new_linked = false;
+ }
+ ar->mixer_state[ctl_index].new_value[id] = value;
+ } else {
+ ALOGE("value id out of range for mixer ctl '%s'",
+ mixer_ctl_get_name(ctl));
+ }
+ } else {
+ ar->mixer_state[ctl_index].new_value[0] = value;
+ ar->mixer_state[ctl_index].new_linked = true;
+ }
+ } else {
+ /* nested ctl (within a path) */
+ mixer_value.ctl = ctl;
+ mixer_value.value = value;
+ if (attr_id)
+ mixer_value.index = atoi((char *)attr_id);
+ else
+ mixer_value.index = -1;
+ path_add_value(state->path, &mixer_value);
+ }
+ }
+
+ state->level++;
+}
+
+static void end_tag(void *data, const XML_Char *tag_name)
+{
+ struct config_parse_state *state = data;
+
+ state->level--;
+}
+
+static int alloc_mixer_state(struct audio_route *ar)
+{
+ unsigned int i;
+ unsigned int j;
+ unsigned int num_values;
+ struct mixer_ctl *ctl;
+ bool linked;
+
+ ar->num_mixer_ctls = mixer_get_num_ctls(ar->mixer);
+ ar->mixer_state = malloc(ar->num_mixer_ctls * sizeof(struct mixer_state));
+ if (!ar->mixer_state)
+ return -1;
+
+ for (i = 0; i < ar->num_mixer_ctls; i++) {
+ ctl = mixer_get_ctl(ar->mixer, i);
+ num_values = mixer_ctl_get_num_values(ctl);
+
+ ar->mixer_state[i].old_value = malloc(num_values * sizeof(int));
+ ar->mixer_state[i].new_value = malloc(num_values * sizeof(int));
+ ar->mixer_state[i].reset_value = malloc(num_values * sizeof(int));
+
+ /*
+ * Get all mixer values for controls with multiple values. If all
+ * values are the same, set the linked flag.
+ */
+ linked = true;
+ for (j = 0; j < num_values; j++) {
+ ar->mixer_state[i].old_value[j] = mixer_ctl_get_value(ctl, j);
+ ar->mixer_state[i].new_value[j] = ar->mixer_state[i].old_value[j];
+
+ /*
+ * If the next value is different from the last, set linked to
+ * false.
+ */
+ if ((j > 0) && (ar->mixer_state[i].old_value[j - 1] !=
+ ar->mixer_state[i].old_value[j])) {
+ linked = false;
+ }
+ }
+ ar->mixer_state[i].ctl = ctl;
+ ar->mixer_state[i].old_linked = linked;
+ ar->mixer_state[i].new_linked = linked;
+ ar->mixer_state[i].num_values = num_values;
+ }
+
+ return 0;
+}
+
+static void free_mixer_state(struct audio_route *ar)
+{
+ unsigned int i;
+
+ for (i = 0; i < ar->num_mixer_ctls; i++) {
+ free(ar->mixer_state[i].old_value);
+ free(ar->mixer_state[i].new_value);
+ free(ar->mixer_state[i].reset_value);
+ }
+
+ free(ar->mixer_state);
+ ar->mixer_state = NULL;
+}
+
+/* Update the mixer with any changed values */
+int audio_route_update_mixer(struct audio_route *ar)
+{
+ unsigned int i;
+ unsigned int j;
+
+ for (i = 0; i < ar->num_mixer_ctls; i++) {
+ unsigned int num_values = ar->mixer_state[i].num_values;
+
+ /* if the value has changed, update the mixer */
+ if (ar->mixer_state[i].new_linked) {
+ if (ar->mixer_state[i].old_value[0] != ar->mixer_state[i].new_value[0]) {
+ /* linked ctl, so set all ctl values the same */
+ for (j = 0; j < num_values; j++)
+ mixer_ctl_set_value(ar->mixer_state[i].ctl, j,
+ ar->mixer_state[i].new_value[0]);
+ ar->mixer_state[i].old_value[0] = ar->mixer_state[i].new_value[0];
+ }
+ } else {
+ for (j = 0; j < num_values; j++) {
+ /*
+ * unlinked ctl, so set each value if necessary.
+ * Note that if the new value is unlinked but the old is
+ * linked, only value 0 is valid, so we always have to
+ * update the mixer for the other values.
+ */
+ if (ar->mixer_state[i].old_linked ||
+ (ar->mixer_state[i].old_value[j] !=
+ ar->mixer_state[i].new_value[j])) {
+ mixer_ctl_set_value(ar->mixer_state[i].ctl, j,
+ ar->mixer_state[i].new_value[j]);
+ ar->mixer_state[i].old_value[j] = ar->mixer_state[i].new_value[j];
+ }
+ }
+ }
+ ar->mixer_state[i].old_linked = ar->mixer_state[i].new_linked;
+ }
+
+ return 0;
+}
+
+/* saves the current state of the mixer, for resetting all controls */
+static void save_mixer_state(struct audio_route *ar)
+{
+ unsigned int i;
+ unsigned int j;
+
+ for (i = 0; i < ar->num_mixer_ctls; i++) {
+ for (j = 0; j < ar->mixer_state[i].num_values; j++) {
+ ar->mixer_state[i].reset_value[j] = ar->mixer_state[i].new_value[j];
+
+ /* if the values are linked, only need to save value 0 */
+ if (ar->mixer_state[i].new_linked)
+ break;
+ }
+ ar->mixer_state[i].reset_linked = ar->mixer_state[i].new_linked;
+ }
+}
+
+/* Reset the audio routes back to the initial state */
+void audio_route_reset(struct audio_route *ar)
+{
+ unsigned int i;
+ unsigned int j;
+
+ /* load all of the saved values */
+ for (i = 0; i < ar->num_mixer_ctls; i++) {
+ for (j = 0; j < ar->mixer_state[i].num_values; j++) {
+ ar->mixer_state[i].new_value[j] = ar->mixer_state[i].reset_value[j];
+
+ /* if the values are linked, only need to save value 0 */
+ if (ar->mixer_state[i].reset_linked)
+ break;
+ }
+ ar->mixer_state[i].new_linked = ar->mixer_state[i].reset_linked;
+ }
+}
+
+/* Apply an audio route path by name */
+int audio_route_apply_path(struct audio_route *ar, const char *name)
+{
+ struct mixer_path *path;
+
+ if (!ar) {
+ ALOGE("invalid audio_route");
+ return -1;
+ }
+
+ path = path_get_by_name(ar, name);
+ if (!path) {
+ ALOGE("unable to find path '%s'", name);
+ return -1;
+ }
+
+ path_apply(ar, path);
+
+ return 0;
+}
+
+struct audio_route *audio_route_init(unsigned int card, const char *xml_path)
+{
+ struct config_parse_state state;
+ XML_Parser parser;
+ FILE *file;
+ int bytes_read;
+ void *buf;
+ int i;
+ struct audio_route *ar;
+
+ ar = calloc(1, sizeof(struct audio_route));
+ if (!ar)
+ goto err_calloc;
+
+ ar->mixer = mixer_open(card);
+ if (!ar->mixer) {
+ ALOGE("Unable to open the mixer, aborting.");
+ goto err_mixer_open;
+ }
+
+ ar->mixer_path = NULL;
+ ar->mixer_path_size = 0;
+ ar->num_mixer_paths = 0;
+
+ /* allocate space for and read current mixer settings */
+ if (alloc_mixer_state(ar) < 0)
+ goto err_mixer_state;
+
+ /* use the default XML path if none is provided */
+ if (xml_path == NULL)
+ xml_path = MIXER_XML_PATH;
+
+ file = fopen(xml_path, "r");
+
+ if (!file) {
+ ALOGE("Failed to open %s", xml_path);
+ goto err_fopen;
+ }
+
+ parser = XML_ParserCreate(NULL);
+ if (!parser) {
+ ALOGE("Failed to create XML parser");
+ goto err_parser_create;
+ }
+
+ memset(&state, 0, sizeof(state));
+ state.ar = ar;
+ XML_SetUserData(parser, &state);
+ XML_SetElementHandler(parser, start_tag, end_tag);
+
+ for (;;) {
+ buf = XML_GetBuffer(parser, BUF_SIZE);
+ if (buf == NULL)
+ goto err_parse;
+
+ bytes_read = fread(buf, 1, BUF_SIZE, file);
+ if (bytes_read < 0)
+ goto err_parse;
+
+ if (XML_ParseBuffer(parser, bytes_read,
+ bytes_read == 0) == XML_STATUS_ERROR) {
+ ALOGE("Error in mixer xml (%s)", MIXER_XML_PATH);
+ goto err_parse;
+ }
+
+ if (bytes_read == 0)
+ break;
+ }
+
+ /* apply the initial mixer values, and save them so we can reset the
+ mixer to the original values */
+ audio_route_update_mixer(ar);
+ save_mixer_state(ar);
+
+ XML_ParserFree(parser);
+ fclose(file);
+ return ar;
+
+err_parse:
+ XML_ParserFree(parser);
+err_parser_create:
+ fclose(file);
+err_fopen:
+ free_mixer_state(ar);
+err_mixer_state:
+ mixer_close(ar->mixer);
+err_mixer_open:
+ free(ar);
+ ar = NULL;
+err_calloc:
+ return NULL;
+}
+
+void audio_route_free(struct audio_route *ar)
+{
+ free_mixer_state(ar);
+ mixer_close(ar->mixer);
+ free(ar);
+}
diff --git a/audio_route/include/audio_route/audio_route.h b/audio_route/include/audio_route/audio_route.h
new file mode 100644
index 0000000..0fea474
--- /dev/null
+++ b/audio_route/include/audio_route/audio_route.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef AUDIO_ROUTE_H
+#define AUDIO_ROUTE_H
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/* Initialize and free the audio routes */
+struct audio_route *audio_route_init(unsigned int card, const char *xml_path);
+void audio_route_free(struct audio_route *ar);
+
+/* Apply an audio route path by name */
+int audio_route_apply_path(struct audio_route *ar, const char *name);
+
+/* Reset the audio routes back to the initial state */
+void audio_route_reset(struct audio_route *ar);
+
+/* Update the mixer with any changed values */
+int audio_route_update_mixer(struct audio_route *ar);
+
+#if defined(__cplusplus)
+} /* extern "C" */
+#endif
+
+#endif
diff --git a/audio_utils/Android.mk b/audio_utils/Android.mk
index e3f3e5e..1ddaced 100644
--- a/audio_utils/Android.mk
+++ b/audio_utils/Android.mk
@@ -21,3 +21,42 @@
libspeexresampler
include $(BUILD_SHARED_LIBRARY)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := libaudioutils
+LOCAL_MODULE_TAGS := optional
+LOCAL_SRC_FILES := \
+ primitives.c
+LOCAL_C_INCLUDES += \
+ $(call include-path-for, audio-utils)
+include $(BUILD_HOST_STATIC_LIBRARY)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := libsndfile
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_SRC_FILES := \
+ tinysndfile.c
+
+LOCAL_C_INCLUDES += \
+ $(call include-path-for, audio-utils)
+
+#LOCAL_SHARED_LIBRARIES := libaudioutils
+
+include $(BUILD_STATIC_LIBRARY)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := libsndfile
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_SRC_FILES := \
+ tinysndfile.c
+
+LOCAL_C_INCLUDES += \
+ $(call include-path-for, audio-utils)
+
+#LOCAL_SHARED_LIBRARIES := libaudioutils
+
+include $(BUILD_HOST_STATIC_LIBRARY)
diff --git a/audio_utils/echo_reference.c b/audio_utils/echo_reference.c
index c05a60f..90f9a9f 100644
--- a/audio_utils/echo_reference.c
+++ b/audio_utils/echo_reference.c
@@ -83,9 +83,11 @@
return -ENODATA;
}
- buffer->frame_count = (buffer->frame_count > er->wr_frames_in) ? er->wr_frames_in : buffer->frame_count;
+ buffer->frame_count = (buffer->frame_count > er->wr_frames_in) ?
+ er->wr_frames_in : buffer->frame_count;
// this is er->rd_channel_count here as we resample after stereo to mono conversion if any
- buffer->i16 = (int16_t *)er->wr_src_buf + (er->wr_curr_frame_size - er->wr_frames_in) * er->rd_channel_count;
+ buffer->i16 = (int16_t *)er->wr_src_buf + (er->wr_curr_frame_size - er->wr_frames_in) *
+ er->rd_channel_count;
return 0;
}
@@ -234,8 +236,8 @@
goto exit;
}
}
- // er->wr_src_buf and er->wr_frames_in are used by getNexBuffer() called by the resampler
- // to get new frames
+ // er->wr_src_buf and er->wr_frames_in are used by getNexBuffer() called by the
+ // resampler to get new frames
if (er->rd_channel_count != er->wr_channel_count) {
er->wr_src_buf = er->wr_buf;
} else {
@@ -373,7 +375,8 @@
int64_t deltaNs = delayNs - expectedDelayNs;
- ALOGV("echo_reference_read(): EchoPathDelayDeviation between reference and DMA [%lld]", deltaNs);
+ ALOGV("echo_reference_read(): EchoPathDelayDeviation between reference and DMA [%lld]",
+ deltaNs);
if (abs(deltaNs) >= MIN_DELAY_DELTA_NS) {
// smooth the variation and update the reference buffer only
// if a deviation in the same direction is observed for more than MIN_DELTA_NUM
@@ -493,7 +496,8 @@
}
if ((rdChannelCount != 1 && rdChannelCount != 2) ||
wrChannelCount != 2) {
- ALOGW("create_echo_reference bad channel count rd %d, wr %d", rdChannelCount, wrChannelCount);
+ ALOGW("create_echo_reference bad channel count rd %d, wr %d", rdChannelCount,
+ wrChannelCount);
return -EINVAL;
}
diff --git a/audio_utils/fixedfft.cpp b/audio_utils/fixedfft.cpp
index 2c92e74..eba84e7 100644
--- a/audio_utils/fixedfft.cpp
+++ b/audio_utils/fixedfft.cpp
@@ -35,7 +35,9 @@
#define LOG_FFT_SIZE 10
#define MAX_FFT_SIZE (1 << LOG_FFT_SIZE)
-static const int32_t twiddle[MAX_FFT_SIZE / 4] = {
+// Actually int32_t, but declare as uint32_t to avoid warnings due to overflow.
+// Be sure to cast all accesses before use, for example "(int32_t) twiddle[...]".
+static const uint32_t twiddle[MAX_FFT_SIZE / 4] = {
0x00008000, 0xff378001, 0xfe6e8002, 0xfda58006, 0xfcdc800a, 0xfc13800f,
0xfb4a8016, 0xfa81801e, 0xf9b88027, 0xf8ef8032, 0xf827803e, 0xf75e804b,
0xf6958059, 0xf5cd8068, 0xf5058079, 0xf43c808b, 0xf374809e, 0xf2ac80b2,
@@ -132,7 +134,7 @@
for (r = 1; r < p; ++r) {
int32_t w = MAX_FFT_SIZE / 4 - (r << scale);
i = w >> 31;
- w = twiddle[(w ^ i) - i] ^ (i << 16);
+ w = ((int32_t) twiddle[(w ^ i) - i]) ^ (i << 16);
for (i = r; i < n; i += p << 1) {
int32_t x = half(v[i]);
int32_t y = mult(w, v[i + p]);
@@ -157,7 +159,7 @@
int32_t z = half(v[n - i]);
int32_t y = z - (x ^ 0xFFFF);
x = half(x + (z ^ 0xFFFF));
- y = mult(y, twiddle[i << scale]);
+ y = mult(y, ((int32_t) twiddle[i << scale]));
v[i] = x - y;
v[n - i] = (x + y) ^ 0xFFFF;
}
diff --git a/audio_utils/include/audio_utils/primitives.h b/audio_utils/include/audio_utils/primitives.h
index 00b5cd9..b34e309 100644
--- a/audio_utils/include/audio_utils/primitives.h
+++ b/audio_utils/include/audio_utils/primitives.h
@@ -18,6 +18,7 @@
#define ANDROID_AUDIO_PRIMITIVES_H
#include <stdint.h>
+#include <stdlib.h>
#include <sys/cdefs.h>
__BEGIN_DECLS
@@ -44,6 +45,17 @@
*/
void memcpy_to_i16_from_u8(int16_t *dst, const uint8_t *src, size_t count);
+/* Shrink and copy samples from signed 16-bit to unsigned 8-bit offset by 0x80.
+ * Parameters:
+ * dst Destination buffer
+ * src Source buffer
+ * count Number of samples to copy
+ * The destination and source buffers must either be completely separate (non-overlapping), or
+ * they must both start at the same address. Partially overlapping buffers are not supported.
+ * The conversion is done by truncation, without dithering, so it loses resolution.
+ */
+void memcpy_to_u8_from_i16(uint8_t *dst, const int16_t *src, size_t count);
+
/* Downmix pairs of interleaved stereo input 16-bit samples to mono output 16-bit samples.
* Parameters:
* dst Destination buffer
diff --git a/audio_utils/include/audio_utils/sndfile.h b/audio_utils/include/audio_utils/sndfile.h
new file mode 100644
index 0000000..c652654
--- /dev/null
+++ b/audio_utils/include/audio_utils/sndfile.h
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __AUDIO_UTIL_SNDFILE_H
+#define __AUDIO_UTIL_SNDFILE_H
+
+// This is a C library for reading and writing PCM .wav files. It is
+// influenced by other libraries such as libsndfile and audiofile, except is
+// much smaller and has an Apache 2.0 license.
+// The API should be familiar to clients of similar libraries, but there is
+// no guarantee that it will stay exactly source-code compatible with other libraries.
+
+#include <stdio.h>
+#include <sys/cdefs.h>
+
+__BEGIN_DECLS
+
+// visible to clients
+typedef int sf_count_t;
+
+typedef struct {
+ sf_count_t frames;
+ int samplerate;
+ int channels;
+ int format;
+} SF_INFO;
+
+// opaque to clients
+typedef struct SNDFILE_ SNDFILE;
+
+// Access modes
+#define SFM_READ 1
+#define SFM_WRITE 2
+
+// Format
+#define SF_FORMAT_TYPEMASK 1
+#define SF_FORMAT_WAV 1
+#define SF_FORMAT_SUBMASK 6
+#define SF_FORMAT_PCM_16 2
+#define SF_FORMAT_PCM_U8 4
+
+// Open stream
+SNDFILE *sf_open(const char *path, int mode, SF_INFO *info);
+
+// Close stream
+void sf_close(SNDFILE *handle);
+
+// Read interleaved frames and return actual number of frames read
+sf_count_t sf_readf_short(SNDFILE *handle, short *ptr, sf_count_t desired);
+
+// Write interleaved frames and return actual number of frames written
+sf_count_t sf_writef_short(SNDFILE *handle, const short *ptr, sf_count_t desired);
+
+__END_DECLS
+
+#endif /* __AUDIO_UTIL_SNDFILE_H */
diff --git a/audio_utils/primitives.c b/audio_utils/primitives.c
index bec87e0..af9ab40 100644
--- a/audio_utils/primitives.c
+++ b/audio_utils/primitives.c
@@ -39,6 +39,13 @@
}
}
+void memcpy_to_u8_from_i16(uint8_t *dst, const int16_t *src, size_t count)
+{
+ while (count--) {
+ *dst++ = (*src++ >> 8) + 0x80;
+ }
+}
+
void downmix_to_mono_i16_from_stereo_i16(int16_t *dst, const int16_t *src, size_t count)
{
while (count--) {
diff --git a/audio_utils/tinysndfile.c b/audio_utils/tinysndfile.c
new file mode 100644
index 0000000..efdb3ce
--- /dev/null
+++ b/audio_utils/tinysndfile.c
@@ -0,0 +1,250 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <audio_utils/sndfile.h>
+#include <audio_utils/primitives.h>
+#include <stdio.h>
+#include <string.h>
+
+struct SNDFILE_ {
+ int mode;
+ uint8_t *temp; // realloc buffer used for shrinking 16 bits to 8 bits and byte-swapping
+ FILE *stream;
+ size_t bytesPerFrame;
+ size_t remaining; // frames unread for SFM_READ, frames written for SFM_WRITE
+ SF_INFO info;
+};
+
+static unsigned little2u(unsigned char *ptr)
+{
+ return (ptr[1] << 8) + ptr[0];
+}
+
+static unsigned little4u(unsigned char *ptr)
+{
+ return (ptr[3] << 24) + (ptr[2] << 16) + (ptr[1] << 8) + ptr[0];
+}
+
+static int isLittleEndian(void)
+{
+ static const short one = 1;
+ return *((const char *) &one) == 1;
+}
+
+static void swab(short *ptr, size_t numToSwap)
+{
+ while (numToSwap > 0) {
+ *ptr = little2u((unsigned char *) ptr);
+ --numToSwap;
+ ++ptr;
+ }
+}
+
+static SNDFILE *sf_open_read(const char *path, SF_INFO *info)
+{
+ FILE *stream = fopen(path, "rb");
+ if (stream == NULL)
+ return NULL;
+ // don't attempt to parse all valid forms, just the most common one
+ unsigned char wav[44];
+ size_t actual;
+ actual = fread(wav, sizeof(char), sizeof(wav), stream);
+ if (actual != sizeof(wav))
+ return NULL;
+ for (;;) {
+ if (memcmp(wav, "RIFF", 4))
+ break;
+ unsigned riffSize = little4u(&wav[4]);
+ if (riffSize < 36)
+ break;
+ if (memcmp(&wav[8], "WAVEfmt ", 8))
+ break;
+ unsigned fmtsize = little4u(&wav[16]);
+ if (fmtsize != 16)
+ break;
+ unsigned format = little2u(&wav[20]);
+ if (format != 1) // PCM
+ break;
+ unsigned channels = little2u(&wav[22]);
+ if (channels != 1 && channels != 2)
+ break;
+ unsigned samplerate = little4u(&wav[24]);
+ if (samplerate == 0)
+ break;
+ // ignore byte rate
+ // ignore block alignment
+ unsigned bitsPerSample = little2u(&wav[34]);
+ if (bitsPerSample != 8 && bitsPerSample != 16)
+ break;
+ unsigned bytesPerFrame = (bitsPerSample >> 3) * channels;
+ if (memcmp(&wav[36], "data", 4))
+ break;
+ unsigned dataSize = little4u(&wav[40]);
+ SNDFILE *handle = (SNDFILE *) malloc(sizeof(SNDFILE));
+ handle->mode = SFM_READ;
+ handle->temp = NULL;
+ handle->stream = stream;
+ handle->bytesPerFrame = bytesPerFrame;
+ handle->remaining = dataSize / bytesPerFrame;
+ handle->info.frames = handle->remaining;
+ handle->info.samplerate = samplerate;
+ handle->info.channels = channels;
+ handle->info.format = SF_FORMAT_WAV;
+ if (bitsPerSample == 8)
+ handle->info.format |= SF_FORMAT_PCM_U8;
+ else
+ handle->info.format |= SF_FORMAT_PCM_16;
+ *info = handle->info;
+ return handle;
+ }
+ return NULL;
+}
+
+static void write4u(unsigned char *ptr, unsigned u)
+{
+ ptr[0] = u;
+ ptr[1] = u >> 8;
+ ptr[2] = u >> 16;
+ ptr[3] = u >> 24;
+}
+
+static SNDFILE *sf_open_write(const char *path, SF_INFO *info)
+{
+ if (!(
+ (info->samplerate > 0) &&
+ (info->channels == 1 || info->channels == 2) &&
+ ((info->format & SF_FORMAT_TYPEMASK) == SF_FORMAT_WAV) &&
+ ((info->format & SF_FORMAT_SUBMASK) == SF_FORMAT_PCM_16 ||
+ (info->format & SF_FORMAT_SUBMASK) == SF_FORMAT_PCM_U8)
+ )) {
+ return NULL;
+ }
+ FILE *stream = fopen(path, "w+b");
+ unsigned char wav[44];
+ memset(wav, 0, sizeof(wav));
+ memcpy(wav, "RIFF", 4);
+ wav[4] = 36; // riffSize
+ memcpy(&wav[8], "WAVEfmt ", 8);
+ wav[16] = 16; // fmtsize
+ wav[20] = 1; // format = PCM
+ wav[22] = info->channels;
+ write4u(&wav[24], info->samplerate);
+ unsigned bitsPerSample = (info->format & SF_FORMAT_SUBMASK) == SF_FORMAT_PCM_16 ? 16 : 8;
+ unsigned blockAlignment = (bitsPerSample >> 3) * info->channels;
+ unsigned byteRate = info->samplerate * blockAlignment;
+ write4u(&wav[28], byteRate);
+ wav[32] = blockAlignment;
+ wav[34] = bitsPerSample;
+ memcpy(&wav[36], "data", 4);
+ // dataSize is initially zero
+ (void) fwrite(wav, sizeof(wav), 1, stream);
+ SNDFILE *handle = (SNDFILE *) malloc(sizeof(SNDFILE));
+ handle->mode = SFM_WRITE;
+ handle->temp = NULL;
+ handle->stream = stream;
+ handle->bytesPerFrame = blockAlignment;
+ handle->remaining = 0;
+ handle->info = *info;
+ return handle;
+}
+
+SNDFILE *sf_open(const char *path, int mode, SF_INFO *info)
+{
+ if (path == NULL || info == NULL)
+ return NULL;
+ switch (mode) {
+ case SFM_READ:
+ return sf_open_read(path, info);
+ case SFM_WRITE:
+ return sf_open_write(path, info);
+ default:
+ return NULL;
+ }
+}
+
+void sf_close(SNDFILE *handle)
+{
+ if (handle == NULL)
+ return;
+ free(handle->temp);
+ if (handle->mode == SFM_WRITE) {
+ (void) fflush(handle->stream);
+ rewind(handle->stream);
+ unsigned char wav[44];
+ (void) fread(wav, sizeof(wav), 1, handle->stream);
+ unsigned dataSize = handle->remaining * handle->bytesPerFrame;
+ write4u(&wav[4], dataSize + 36); // riffSize
+ write4u(&wav[40], dataSize); // dataSize
+ rewind(handle->stream);
+ (void) fwrite(wav, sizeof(wav), 1, handle->stream);
+ }
+ (void) fclose(handle->stream);
+ free(handle);
+}
+
+sf_count_t sf_readf_short(SNDFILE *handle, short *ptr, sf_count_t desiredFrames)
+{
+ if (handle == NULL || handle->mode != SFM_READ || ptr == NULL || !handle->remaining ||
+ desiredFrames <= 0) {
+ return 0;
+ }
+ if (handle->remaining < (size_t) desiredFrames)
+ desiredFrames = handle->remaining;
+ size_t desiredBytes = desiredFrames * handle->bytesPerFrame;
+ // does not check for numeric overflow
+ size_t actualBytes = fread(ptr, sizeof(char), desiredBytes, handle->stream);
+ size_t actualFrames = actualBytes / handle->bytesPerFrame;
+ handle->remaining -= actualFrames;
+ switch (handle->info.format & SF_FORMAT_SUBMASK) {
+ case SF_FORMAT_PCM_U8:
+ memcpy_to_i16_from_u8(ptr, (unsigned char *) ptr, actualFrames * handle->info.channels);
+ break;
+ case SF_FORMAT_PCM_16:
+ if (!isLittleEndian())
+ swab(ptr, actualFrames * handle->info.channels);
+ break;
+ }
+ return actualFrames;
+}
+
+sf_count_t sf_writef_short(SNDFILE *handle, const short *ptr, sf_count_t desiredFrames)
+{
+ if (handle == NULL || handle->mode != SFM_WRITE || ptr == NULL || desiredFrames <= 0)
+ return 0;
+ size_t desiredBytes = desiredFrames * handle->bytesPerFrame;
+ size_t actualBytes = 0;
+ switch (handle->info.format & SF_FORMAT_SUBMASK) {
+ case SF_FORMAT_PCM_U8:
+ handle->temp = realloc(handle->temp, desiredBytes);
+ memcpy_to_u8_from_i16(handle->temp, ptr, desiredBytes);
+ actualBytes = fwrite(handle->temp, sizeof(char), desiredBytes, handle->stream);
+ break;
+ case SF_FORMAT_PCM_16:
+ // does not check for numeric overflow
+ if (isLittleEndian()) {
+ actualBytes = fwrite(ptr, sizeof(char), desiredBytes, handle->stream);
+ } else {
+ handle->temp = realloc(handle->temp, desiredBytes);
+ memcpy(handle->temp, ptr, desiredBytes);
+ swab((short *) handle->temp, desiredFrames * handle->info.channels);
+ actualBytes = fwrite(handle->temp, sizeof(char), desiredBytes, handle->stream);
+ }
+ break;
+ }
+ size_t actualFrames = actualBytes / handle->bytesPerFrame;
+ handle->remaining += actualFrames;
+ return actualFrames;
+}
diff --git a/camera/docs/README.md b/camera/docs/README.md
new file mode 100644
index 0000000..3cdae4d
--- /dev/null
+++ b/camera/docs/README.md
@@ -0,0 +1,26 @@
+# Camera Metadata XML
+## Introduction
+This is a set of scripts to manipulate the camera metadata in an XML form.
+
+## Generated Files
+Many files can be generated from XML, such as the documentation (html/pdf),
+C code, Java code, and even XML itself (as a sanity check).
+
+## Dependencies
+* Python 2.7.x+
+* Beautiful Soup 4+ - HTML/XML parser, used to parse metadata_properties.xml
+* Mako 0.7+ - Template engine, needed to do file generation
+* Tidy - Cleans up the XML/HTML files.
+* XML Lint - Validates XML against XSD schema
+
+## Quick Setup (Ubuntu Precise):
+sudo apt-get install python-mako
+sudo apt-get install python-bs4
+sudo apt-get install tidy
+sudo apt-get install libxml2-utils #xmllint
+
+## Quick Setup (MacPorts)
+sudo port install py27-beautifulsoup4
+sudo port install py27-mako
+sudo port install tidy
+sudo port install libxml2 #xmllint
diff --git a/camera/docs/camera_metadata_tag_info.mako b/camera/docs/camera_metadata_tag_info.mako
new file mode 100644
index 0000000..bfe5d86
--- /dev/null
+++ b/camera/docs/camera_metadata_tag_info.mako
@@ -0,0 +1,105 @@
+## -*- coding: utf-8 -*-
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * !! Do not reference this file directly !!
+ *
+ * It is logically a part of camera_metadata.c. It is broken out for ease of
+ * maintaining the tag info.
+ *
+ * Array assignments are done using specified-index syntax to keep things in
+ * sync with camera_metadata_tags.h
+ */
+
+/**
+ * ! Do not edit this file directly !
+ *
+ * Generated automatically from camera_metadata_tag_info.mako
+ */
+
+const char *camera_metadata_section_names[ANDROID_SECTION_COUNT] = {
+ % for i in find_all_sections(metadata):
+ ${"[%s]" %(path_name(i)) | csym,pad(36)} = "${path_name(i)}",
+ % endfor
+};
+
+unsigned int camera_metadata_section_bounds[ANDROID_SECTION_COUNT][2] = {
+ % for i in find_all_sections(metadata):
+ ${"[%s]" %(path_name(i)) | csym,pad(36)} = { ${path_name(i) | csym}_START,
+ ${path_name(i) | csym}_END },
+ % endfor
+};
+
+% for sec in find_all_sections(metadata):
+static tag_info_t ${path_name(sec) | csyml}[${path_name(sec) | csym}_END -
+ ${path_name(sec) | csym}_START] = {
+ % for entry in find_unique_entries(sec):
+ [ ${entry.name | csym} - ${path_name(sec) | csym}_START ] =
+ { ${'"%s",' %(entry.name_short) | pad(40)} ${entry.type | ctype_enum,ljust(11)} },
+ % endfor
+};
+
+% endfor
+
+tag_info_t *tag_info[ANDROID_SECTION_COUNT] = {
+ % for i in find_all_sections(metadata):
+ ${path_name(i) | csyml},
+ % endfor
+};
+
+int camera_metadata_enum_snprint(uint32_t tag,
+ uint32_t value,
+ char *dst,
+ size_t size) {
+ const char *msg = "error: not an enum";
+ int ret = -1;
+
+ switch(tag) {
+ % for sec in find_all_sections(metadata):
+ % for idx,entry in enumerate(find_unique_entries(sec)):
+ case ${entry.name | csym}: {
+ % if entry.enum:
+ switch (value) {
+ % for val in entry.enum.values:
+ case ${entry.name | csym}_${val.name}:
+ msg = "${val.name}";
+ ret = 0;
+ break;
+ % endfor
+ default:
+ msg = "error: enum value out of range";
+ }
+ % endif
+ break;
+ }
+ % endfor
+
+ %endfor
+ }
+
+ strncpy(dst, msg, size - 1);
+ dst[size - 1] = '\0';
+
+ return ret;
+}
+
+<%
+ find_values = lambda x: isinstance(x, metadata_model.EnumValue)
+ enum_values = metadata.find_all(find_values)
+ enum_value_max_len = max([len(value.name) for value in enum_values]) + 1
+%>
+#define CAMERA_METADATA_ENUM_STRING_MAX_SIZE ${enum_value_max_len}
diff --git a/camera/docs/camera_metadata_tags.mako b/camera/docs/camera_metadata_tags.mako
new file mode 100644
index 0000000..d7a5564
--- /dev/null
+++ b/camera/docs/camera_metadata_tags.mako
@@ -0,0 +1,104 @@
+## -*- coding: utf-8 -*-
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * !! Do not include this file directly !!
+ *
+ * Include camera_metadata.h instead.
+ */
+
+/**
+ * ! Do not edit this file directly !
+ *
+ * Generated automatically from camera_metadata_tags.mako
+ */
+
+/** TODO: Nearly every enum in this file needs a description */
+
+/**
+ * Top level hierarchy definitions for camera metadata. *_INFO sections are for
+ * the static metadata that can be retrived without opening the camera device.
+ * New sections must be added right before ANDROID_SECTION_COUNT to maintain
+ * existing enumerations.
+ */
+typedef enum camera_metadata_section {
+ % for i in find_all_sections(metadata):
+ ${path_name(i) | csym},
+ % endfor
+ ANDROID_SECTION_COUNT,
+
+ VENDOR_SECTION = 0x8000
+} camera_metadata_section_t;
+
+/**
+ * Hierarchy positions in enum space. All vendor extension tags must be
+ * defined with tag >= VENDOR_SECTION_START
+ */
+typedef enum camera_metadata_section_start {
+ % for i in find_all_sections(metadata):
+ ${path_name(i) + '.start' | csym,ljust(30)} = ${path_name(i) | csym,pad(64)} << 16,
+ % endfor
+ VENDOR_SECTION_START = VENDOR_SECTION << 16
+} camera_metadata_section_start_t;
+
+/**
+ * Main enum for defining camera metadata tags. New entries must always go
+ * before the section _END tag to preserve existing enumeration values. In
+ * addition, the name and type of the tag needs to be added to
+ * system/media/camera/src/camera_metadata_tag_info.c
+ */
+typedef enum camera_metadata_tag {
+ % for sec in find_all_sections(metadata):
+ % for idx,entry in enumerate(find_unique_entries(sec)):
+ % if idx == 0:
+ ${entry.name | csym,ljust(30)} = ${path_name(find_parent_section(entry)) | csym}_START,
+ % else:
+ ${entry.name | csym},
+ % endif
+ % endfor
+ ${path_name(sec) | csym}_END,
+
+ %endfor
+} camera_metadata_tag_t;
+
+/**
+ * Enumeration definitions for the various entries that need them
+ */
+
+% for sec in find_all_sections(metadata):
+ % for entry in find_unique_entries(sec):
+ % if entry.enum:
+// ${entry.name | csym}
+typedef enum camera_metadata_enum_${csym(entry.name).lower()} {
+ % for val in entry.enum.values:
+ % if val.id is None:
+ ${entry.name | csym}_${val.name},
+ % else:
+ ${'%s_%s'%(csym(entry.name), val.name) | pad(65)} = ${val.id},
+ % endif
+ % endfor
+} camera_metadata_enum_${csym(entry.name).lower()}_t;
+
+ % endif
+ % endfor
+
+%endfor
+
+int camera_metadata_enum_snprint(uint32_t tag,
+ uint32_t value,
+ char *dst,
+ size_t size);
diff --git a/camera/docs/docs.html b/camera/docs/docs.html
new file mode 100644
index 0000000..9f5ad50
--- /dev/null
+++ b/camera/docs/docs.html
@@ -0,0 +1,9930 @@
+<!DOCTYPE html>
+<html>
+<!-- Copyright (C) 2012 The Android Open Source Project
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+<head>
+ <!-- automatically generated from html.mako. do NOT edit directly -->
+ <meta charset="utf-8" />
+ <title>Android Camera HAL2.0 Properties</title>
+ <style type="text/css">
+ .section { font-size: 1.5em; font-weight: bold; background-color: beige; padding: 0.5em 0em 0.5em 0.1em }
+ .kind { font-size: 1.2em; font-weight: bold; padding-left: 0.5em; background-color: gray }
+ .entry { background-color: burlywood }
+
+ /* table column sizes */
+ table { table-layout: fixed; width: 100%; word-wrap: break-word }
+ td,th { border: 1px solid; }
+ .th_name { width: 20% }
+ .th_units { width: 10% }
+ .th_tags { width: 5% }
+ .th_notes { width: 30% }
+ .th_type { width: 20% }
+ td { font-size: 0.9em; }
+
+ /* hide the first thead, we need it there only to enforce column sizes */
+ .thead_dummy { visibility: hidden; }
+
+ /* Entry flair */
+ .entry_name { font-family: monospace; font-style: italic; }
+
+ /* Entry type flair */
+ .entry_type_name { color: darkgreen; font-weight: bold; }
+ .entry_type_name_enum:after { color: darkgreen; font-weight: bold; content:" (enum)" }
+ .entry_type_enum_name { font-family: monospace; font-weight: bolder; }
+ .entry_type_enum_notes:before { content:" - " }
+ .entry_type_enum_value:before { content:" = " }
+ .entry_type_enum_value { font-family: monospace; }
+ .entry ul { margin: 0 0 0 0; list-style-position: inside; padding-left: 0.5em; }
+ .entry ul li { padding: 0 0 0 0; margin: 0 0 0 0;}
+
+ /* Entry tags flair */
+ .entry_tags ul { list-style-type: none; }
+
+
+ /* TODO: generate abbr element for each tag link? */
+ /* TODO for each x.y.z try to link it to the entry */
+
+ </style>
+
+ <style>
+
+ {
+ /* broken...
+ supposedly there is a bug in chrome that it lays out tables before
+ it knows its being printed, so the page-break-* styles are ignored
+ */
+ tr { page-break-after: always; page-break-inside: avoid; }
+ }
+
+ </style>
+</head>
+
+
+
+
+<body>
+ <h1>Android Camera HAL2.0 Properties</h1>
+
+ <h2>Table of Contents</h2>
+ <ul class="toc">
+ <li><a href="#tag_index">Tags</a></li>
+
+
+ <li><p class="toc_section"><a href="#section_colorCorrection">colorCorrection</a></p>
+ <ul class="toc_section">
+ <li><a href="#controls_android.colorCorrection.mode">android.colorCorrection.mode</a> (controls)</li>
+ <li><a href="#controls_android.colorCorrection.transform">android.colorCorrection.transform</a> (controls)</li>
+ <li><a href="#dynamic_android.colorCorrection.mode">android.colorCorrection.mode</a> (dynamic)</li>
+ </ul>
+ </li> <!-- toc_section -->
+ <li><p class="toc_section"><a href="#section_control">control</a></p>
+ <ul class="toc_section">
+ <li><a href="#controls_android.control.aeAntibandingMode">android.control.aeAntibandingMode</a> (controls)</li>
+ <li><a href="#controls_android.control.aeExposureCompensation">android.control.aeExposureCompensation</a> (controls)</li>
+ <li><a href="#controls_android.control.aeLock">android.control.aeLock</a> (controls)</li>
+ <li><a href="#controls_android.control.aeMode">android.control.aeMode</a> (controls)</li>
+ <li><a href="#controls_android.control.aeRegions">android.control.aeRegions</a> (controls)</li>
+ <li><a href="#controls_android.control.aeTargetFpsRange">android.control.aeTargetFpsRange</a> (controls)</li>
+ <li><a href="#controls_android.control.afMode">android.control.afMode</a> (controls)</li>
+ <li><a href="#controls_android.control.afRegions">android.control.afRegions</a> (controls)</li>
+ <li><a href="#controls_android.control.awbLock">android.control.awbLock</a> (controls)</li>
+ <li><a href="#controls_android.control.awbMode">android.control.awbMode</a> (controls)</li>
+ <li><a href="#controls_android.control.awbRegions">android.control.awbRegions</a> (controls)</li>
+ <li><a href="#controls_android.control.captureIntent">android.control.captureIntent</a> (controls)</li>
+ <li><a href="#controls_android.control.effectMode">android.control.effectMode</a> (controls)</li>
+ <li><a href="#controls_android.control.mode">android.control.mode</a> (controls)</li>
+ <li><a href="#controls_android.control.sceneMode">android.control.sceneMode</a> (controls)</li>
+ <li><a href="#controls_android.control.videoStabilizationMode">android.control.videoStabilizationMode</a> (controls)</li>
+ <li><a href="#static_android.control.aeAvailableAntibandingModes">android.control.aeAvailableAntibandingModes</a> (static)</li>
+ <li><a href="#static_android.control.aeAvailableModes">android.control.aeAvailableModes</a> (static)</li>
+ <li><a href="#static_android.control.aeAvailableTargetFpsRanges">android.control.aeAvailableTargetFpsRanges</a> (static)</li>
+ <li><a href="#static_android.control.aeCompensationRange">android.control.aeCompensationRange</a> (static)</li>
+ <li><a href="#static_android.control.aeCompensationStep">android.control.aeCompensationStep</a> (static)</li>
+ <li><a href="#static_android.control.afAvailableModes">android.control.afAvailableModes</a> (static)</li>
+ <li><a href="#static_android.control.availableEffects">android.control.availableEffects</a> (static)</li>
+ <li><a href="#static_android.control.availableSceneModes">android.control.availableSceneModes</a> (static)</li>
+ <li><a href="#static_android.control.availableVideoStabilizationModes">android.control.availableVideoStabilizationModes</a> (static)</li>
+ <li><a href="#static_android.control.awbAvailableModes">android.control.awbAvailableModes</a> (static)</li>
+ <li><a href="#static_android.control.maxRegions">android.control.maxRegions</a> (static)</li>
+ <li><a href="#static_android.control.sceneModeOverrides">android.control.sceneModeOverrides</a> (static)</li>
+ <li><a href="#dynamic_android.control.aePrecaptureId">android.control.aePrecaptureId</a> (dynamic)</li>
+ <li><a href="#dynamic_android.control.aeRegions">android.control.aeRegions</a> (dynamic)</li>
+ <li><a href="#dynamic_android.control.aeState">android.control.aeState</a> (dynamic)</li>
+ <li><a href="#dynamic_android.control.afMode">android.control.afMode</a> (dynamic)</li>
+ <li><a href="#dynamic_android.control.afRegions">android.control.afRegions</a> (dynamic)</li>
+ <li><a href="#dynamic_android.control.afState">android.control.afState</a> (dynamic)</li>
+ <li><a href="#dynamic_android.control.afTriggerId">android.control.afTriggerId</a> (dynamic)</li>
+ <li><a href="#dynamic_android.control.awbMode">android.control.awbMode</a> (dynamic)</li>
+ <li><a href="#dynamic_android.control.awbRegions">android.control.awbRegions</a> (dynamic)</li>
+ <li><a href="#dynamic_android.control.awbState">android.control.awbState</a> (dynamic)</li>
+ <li><a href="#dynamic_android.control.mode">android.control.mode</a> (dynamic)</li>
+ </ul>
+ </li> <!-- toc_section -->
+ <li><p class="toc_section"><a href="#section_demosaic">demosaic</a></p>
+ <ul class="toc_section">
+ <li><a href="#controls_android.demosaic.mode">android.demosaic.mode</a> (controls)</li>
+ </ul>
+ </li> <!-- toc_section -->
+ <li><p class="toc_section"><a href="#section_edge">edge</a></p>
+ <ul class="toc_section">
+ <li><a href="#controls_android.edge.mode">android.edge.mode</a> (controls)</li>
+ <li><a href="#controls_android.edge.strength">android.edge.strength</a> (controls)</li>
+ <li><a href="#dynamic_android.edge.mode">android.edge.mode</a> (dynamic)</li>
+ </ul>
+ </li> <!-- toc_section -->
+ <li><p class="toc_section"><a href="#section_flash">flash</a></p>
+ <ul class="toc_section">
+ <li><a href="#controls_android.flash.firingPower">android.flash.firingPower</a> (controls)</li>
+ <li><a href="#controls_android.flash.firingTime">android.flash.firingTime</a> (controls)</li>
+ <li><a href="#controls_android.flash.mode">android.flash.mode</a> (controls)</li>
+ <li><a href="#static_android.flash.info.available">android.flash.info.available</a> (static)</li>
+ <li><a href="#static_android.flash.info.chargeDuration">android.flash.info.chargeDuration</a> (static)</li>
+ <li><a href="#static_android.flash.colorTemperature">android.flash.colorTemperature</a> (static)</li>
+ <li><a href="#static_android.flash.maxEnergy">android.flash.maxEnergy</a> (static)</li>
+ <li><a href="#dynamic_android.flash.firingPower">android.flash.firingPower</a> (dynamic)</li>
+ <li><a href="#dynamic_android.flash.firingTime">android.flash.firingTime</a> (dynamic)</li>
+ <li><a href="#dynamic_android.flash.mode">android.flash.mode</a> (dynamic)</li>
+ <li><a href="#dynamic_android.flash.state">android.flash.state</a> (dynamic)</li>
+ </ul>
+ </li> <!-- toc_section -->
+ <li><p class="toc_section"><a href="#section_geometric">geometric</a></p>
+ <ul class="toc_section">
+ <li><a href="#controls_android.geometric.mode">android.geometric.mode</a> (controls)</li>
+ <li><a href="#controls_android.geometric.strength">android.geometric.strength</a> (controls)</li>
+ </ul>
+ </li> <!-- toc_section -->
+ <li><p class="toc_section"><a href="#section_hotPixel">hotPixel</a></p>
+ <ul class="toc_section">
+ <li><a href="#controls_android.hotPixel.mode">android.hotPixel.mode</a> (controls)</li>
+ <li><a href="#static_android.hotPixel.info.map">android.hotPixel.info.map</a> (static)</li>
+ <li><a href="#dynamic_android.hotPixel.mode">android.hotPixel.mode</a> (dynamic)</li>
+ </ul>
+ </li> <!-- toc_section -->
+ <li><p class="toc_section"><a href="#section_jpeg">jpeg</a></p>
+ <ul class="toc_section">
+ <li><a href="#controls_android.jpeg.gpsCoordinates">android.jpeg.gpsCoordinates</a> (controls)</li>
+ <li><a href="#controls_android.jpeg.gpsProcessingMethod">android.jpeg.gpsProcessingMethod</a> (controls)</li>
+ <li><a href="#controls_android.jpeg.gpsTimestamp">android.jpeg.gpsTimestamp</a> (controls)</li>
+ <li><a href="#controls_android.jpeg.orientation">android.jpeg.orientation</a> (controls)</li>
+ <li><a href="#controls_android.jpeg.quality">android.jpeg.quality</a> (controls)</li>
+ <li><a href="#controls_android.jpeg.thumbnailQuality">android.jpeg.thumbnailQuality</a> (controls)</li>
+ <li><a href="#controls_android.jpeg.thumbnailSize">android.jpeg.thumbnailSize</a> (controls)</li>
+ <li><a href="#static_android.jpeg.availableThumbnailSizes">android.jpeg.availableThumbnailSizes</a> (static)</li>
+ <li><a href="#static_android.jpeg.maxSize">android.jpeg.maxSize</a> (static)</li>
+ <li><a href="#dynamic_android.jpeg.gpsCoordinates">android.jpeg.gpsCoordinates</a> (dynamic)</li>
+ <li><a href="#dynamic_android.jpeg.gpsProcessingMethod">android.jpeg.gpsProcessingMethod</a> (dynamic)</li>
+ <li><a href="#dynamic_android.jpeg.gpsTimestamp">android.jpeg.gpsTimestamp</a> (dynamic)</li>
+ <li><a href="#dynamic_android.jpeg.orientation">android.jpeg.orientation</a> (dynamic)</li>
+ <li><a href="#dynamic_android.jpeg.quality">android.jpeg.quality</a> (dynamic)</li>
+ <li><a href="#dynamic_android.jpeg.size">android.jpeg.size</a> (dynamic)</li>
+ <li><a href="#dynamic_android.jpeg.thumbnailQuality">android.jpeg.thumbnailQuality</a> (dynamic)</li>
+ <li><a href="#dynamic_android.jpeg.thumbnailSize">android.jpeg.thumbnailSize</a> (dynamic)</li>
+ </ul>
+ </li> <!-- toc_section -->
+ <li><p class="toc_section"><a href="#section_lens">lens</a></p>
+ <ul class="toc_section">
+ <li><a href="#controls_android.lens.aperture">android.lens.aperture</a> (controls)</li>
+ <li><a href="#controls_android.lens.filterDensity">android.lens.filterDensity</a> (controls)</li>
+ <li><a href="#controls_android.lens.focalLength">android.lens.focalLength</a> (controls)</li>
+ <li><a href="#controls_android.lens.focusDistance">android.lens.focusDistance</a> (controls)</li>
+ <li><a href="#controls_android.lens.opticalStabilizationMode">android.lens.opticalStabilizationMode</a> (controls)</li>
+ <li><a href="#static_android.lens.info.availableApertures">android.lens.info.availableApertures</a> (static)</li>
+ <li><a href="#static_android.lens.info.availableFilterDensities">android.lens.info.availableFilterDensities</a> (static)</li>
+ <li><a href="#static_android.lens.info.availableFocalLengths">android.lens.info.availableFocalLengths</a> (static)</li>
+ <li><a href="#static_android.lens.info.availableOpticalStabilization">android.lens.info.availableOpticalStabilization</a> (static)</li>
+ <li><a href="#static_android.lens.info.geometricCorrectionMap">android.lens.info.geometricCorrectionMap</a> (static)</li>
+ <li><a href="#static_android.lens.info.geometricCorrectionMapSize">android.lens.info.geometricCorrectionMapSize</a> (static)</li>
+ <li><a href="#static_android.lens.info.hyperfocalDistance">android.lens.info.hyperfocalDistance</a> (static)</li>
+ <li><a href="#static_android.lens.info.minimumFocusDistance">android.lens.info.minimumFocusDistance</a> (static)</li>
+ <li><a href="#static_android.lens.info.shadingMap">android.lens.info.shadingMap</a> (static)</li>
+ <li><a href="#static_android.lens.info.shadingMapSize">android.lens.info.shadingMapSize</a> (static)</li>
+ <li><a href="#static_android.lens.facing">android.lens.facing</a> (static)</li>
+ <li><a href="#static_android.lens.opticalAxisAngle">android.lens.opticalAxisAngle</a> (static)</li>
+ <li><a href="#static_android.lens.position">android.lens.position</a> (static)</li>
+ <li><a href="#dynamic_android.lens.aperture">android.lens.aperture</a> (dynamic)</li>
+ <li><a href="#dynamic_android.lens.filterDensity">android.lens.filterDensity</a> (dynamic)</li>
+ <li><a href="#dynamic_android.lens.focalLength">android.lens.focalLength</a> (dynamic)</li>
+ <li><a href="#dynamic_android.lens.focusDistance">android.lens.focusDistance</a> (dynamic)</li>
+ <li><a href="#dynamic_android.lens.focusRange">android.lens.focusRange</a> (dynamic)</li>
+ <li><a href="#dynamic_android.lens.opticalStabilizationMode">android.lens.opticalStabilizationMode</a> (dynamic)</li>
+ <li><a href="#dynamic_android.lens.state">android.lens.state</a> (dynamic)</li>
+ </ul>
+ </li> <!-- toc_section -->
+ <li><p class="toc_section"><a href="#section_noiseReduction">noiseReduction</a></p>
+ <ul class="toc_section">
+ <li><a href="#controls_android.noiseReduction.mode">android.noiseReduction.mode</a> (controls)</li>
+ <li><a href="#controls_android.noiseReduction.strength">android.noiseReduction.strength</a> (controls)</li>
+ <li><a href="#dynamic_android.noiseReduction.mode">android.noiseReduction.mode</a> (dynamic)</li>
+ </ul>
+ </li> <!-- toc_section -->
+ <li><p class="toc_section"><a href="#section_quirks">quirks</a></p>
+ <ul class="toc_section">
+ <li><a href="#static_android.quirks.meteringCropRegion">android.quirks.meteringCropRegion</a> (static)</li>
+ <li><a href="#static_android.quirks.triggerAfWithAuto">android.quirks.triggerAfWithAuto</a> (static)</li>
+ <li><a href="#static_android.quirks.useZslFormat">android.quirks.useZslFormat</a> (static)</li>
+ </ul>
+ </li> <!-- toc_section -->
+ <li><p class="toc_section"><a href="#section_request">request</a></p>
+ <ul class="toc_section">
+ <li><a href="#controls_android.request.frameCount">android.request.frameCount</a> (controls)</li>
+ <li><a href="#controls_android.request.id">android.request.id</a> (controls)</li>
+ <li><a href="#controls_android.request.inputStreams">android.request.inputStreams</a> (controls)</li>
+ <li><a href="#controls_android.request.metadataMode">android.request.metadataMode</a> (controls)</li>
+ <li><a href="#controls_android.request.outputStreams">android.request.outputStreams</a> (controls)</li>
+ <li><a href="#controls_android.request.type">android.request.type</a> (controls)</li>
+ <li><a href="#static_android.request.maxNumOutputStreams">android.request.maxNumOutputStreams</a> (static)</li>
+ <li><a href="#static_android.request.maxNumReprocessStreams">android.request.maxNumReprocessStreams</a> (static)</li>
+ <li><a href="#dynamic_android.request.frameCount">android.request.frameCount</a> (dynamic)</li>
+ <li><a href="#dynamic_android.request.id">android.request.id</a> (dynamic)</li>
+ <li><a href="#dynamic_android.request.metadataMode">android.request.metadataMode</a> (dynamic)</li>
+ <li><a href="#dynamic_android.request.outputStreams">android.request.outputStreams</a> (dynamic)</li>
+ </ul>
+ </li> <!-- toc_section -->
+ <li><p class="toc_section"><a href="#section_scaler">scaler</a></p>
+ <ul class="toc_section">
+ <li><a href="#controls_android.scaler.cropRegion">android.scaler.cropRegion</a> (controls)</li>
+ <li><a href="#static_android.scaler.availableFormats">android.scaler.availableFormats</a> (static)</li>
+ <li><a href="#static_android.scaler.availableJpegMinDurations">android.scaler.availableJpegMinDurations</a> (static)</li>
+ <li><a href="#static_android.scaler.availableJpegSizes">android.scaler.availableJpegSizes</a> (static)</li>
+ <li><a href="#static_android.scaler.availableMaxDigitalZoom">android.scaler.availableMaxDigitalZoom</a> (static)</li>
+ <li><a href="#static_android.scaler.availableProcessedMinDurations">android.scaler.availableProcessedMinDurations</a> (static)</li>
+ <li><a href="#static_android.scaler.availableProcessedSizes">android.scaler.availableProcessedSizes</a> (static)</li>
+ <li><a href="#static_android.scaler.availableRawMinDurations">android.scaler.availableRawMinDurations</a> (static)</li>
+ <li><a href="#static_android.scaler.availableRawSizes">android.scaler.availableRawSizes</a> (static)</li>
+ <li><a href="#static_android.scaler.maxDigitalZoom">android.scaler.maxDigitalZoom</a> (static)</li>
+ <li><a href="#dynamic_android.scaler.cropRegion">android.scaler.cropRegion</a> (dynamic)</li>
+ </ul>
+ </li> <!-- toc_section -->
+ <li><p class="toc_section"><a href="#section_sensor">sensor</a></p>
+ <ul class="toc_section">
+ <li><a href="#controls_android.sensor.exposureTime">android.sensor.exposureTime</a> (controls)</li>
+ <li><a href="#controls_android.sensor.frameDuration">android.sensor.frameDuration</a> (controls)</li>
+ <li><a href="#controls_android.sensor.sensitivity">android.sensor.sensitivity</a> (controls)</li>
+ <li><a href="#static_android.sensor.info.activeArraySize">android.sensor.info.activeArraySize</a> (static)</li>
+ <li><a href="#static_android.sensor.info.availableSensitivities">android.sensor.info.availableSensitivities</a> (static)</li>
+ <li><a href="#static_android.sensor.info.colorFilterArrangement">android.sensor.info.colorFilterArrangement</a> (static)</li>
+ <li><a href="#static_android.sensor.info.exposureTimeRange">android.sensor.info.exposureTimeRange</a> (static)</li>
+ <li><a href="#static_android.sensor.info.maxFrameDuration">android.sensor.info.maxFrameDuration</a> (static)</li>
+ <li><a href="#static_android.sensor.info.physicalSize">android.sensor.info.physicalSize</a> (static)</li>
+ <li><a href="#static_android.sensor.info.pixelArraySize">android.sensor.info.pixelArraySize</a> (static)</li>
+ <li><a href="#static_android.sensor.info.whiteLevel">android.sensor.info.whiteLevel</a> (static)</li>
+ <li><a href="#static_android.sensor.baseGainFactor">android.sensor.baseGainFactor</a> (static)</li>
+ <li><a href="#static_android.sensor.blackLevelPattern">android.sensor.blackLevelPattern</a> (static)</li>
+ <li><a href="#static_android.sensor.calibrationTransform1">android.sensor.calibrationTransform1</a> (static)</li>
+ <li><a href="#static_android.sensor.calibrationTransform2">android.sensor.calibrationTransform2</a> (static)</li>
+ <li><a href="#static_android.sensor.colorTransform1">android.sensor.colorTransform1</a> (static)</li>
+ <li><a href="#static_android.sensor.colorTransform2">android.sensor.colorTransform2</a> (static)</li>
+ <li><a href="#static_android.sensor.forwardMatrix1">android.sensor.forwardMatrix1</a> (static)</li>
+ <li><a href="#static_android.sensor.forwardMatrix2">android.sensor.forwardMatrix2</a> (static)</li>
+ <li><a href="#static_android.sensor.maxAnalogSensitivity">android.sensor.maxAnalogSensitivity</a> (static)</li>
+ <li><a href="#static_android.sensor.noiseModelCoefficients">android.sensor.noiseModelCoefficients</a> (static)</li>
+ <li><a href="#static_android.sensor.orientation">android.sensor.orientation</a> (static)</li>
+ <li><a href="#static_android.sensor.referenceIlluminant1">android.sensor.referenceIlluminant1</a> (static)</li>
+ <li><a href="#static_android.sensor.referenceIlluminant2">android.sensor.referenceIlluminant2</a> (static)</li>
+ <li><a href="#dynamic_android.sensor.exposureTime">android.sensor.exposureTime</a> (dynamic)</li>
+ <li><a href="#dynamic_android.sensor.frameDuration">android.sensor.frameDuration</a> (dynamic)</li>
+ <li><a href="#dynamic_android.sensor.sensitivity">android.sensor.sensitivity</a> (dynamic)</li>
+ <li><a href="#dynamic_android.sensor.timestamp">android.sensor.timestamp</a> (dynamic)</li>
+ </ul>
+ </li> <!-- toc_section -->
+ <li><p class="toc_section"><a href="#section_shading">shading</a></p>
+ <ul class="toc_section">
+ <li><a href="#controls_android.shading.mode">android.shading.mode</a> (controls)</li>
+ <li><a href="#controls_android.shading.strength">android.shading.strength</a> (controls)</li>
+ <li><a href="#dynamic_android.shading.mode">android.shading.mode</a> (dynamic)</li>
+ </ul>
+ </li> <!-- toc_section -->
+ <li><p class="toc_section"><a href="#section_statistics">statistics</a></p>
+ <ul class="toc_section">
+ <li><a href="#controls_android.statistics.faceDetectMode">android.statistics.faceDetectMode</a> (controls)</li>
+ <li><a href="#controls_android.statistics.histogramMode">android.statistics.histogramMode</a> (controls)</li>
+ <li><a href="#controls_android.statistics.sharpnessMapMode">android.statistics.sharpnessMapMode</a> (controls)</li>
+ <li><a href="#static_android.statistics.info.availableFaceDetectModes">android.statistics.info.availableFaceDetectModes</a> (static)</li>
+ <li><a href="#static_android.statistics.info.histogramBucketCount">android.statistics.info.histogramBucketCount</a> (static)</li>
+ <li><a href="#static_android.statistics.info.maxFaceCount">android.statistics.info.maxFaceCount</a> (static)</li>
+ <li><a href="#static_android.statistics.info.maxHistogramCount">android.statistics.info.maxHistogramCount</a> (static)</li>
+ <li><a href="#static_android.statistics.info.maxSharpnessMapValue">android.statistics.info.maxSharpnessMapValue</a> (static)</li>
+ <li><a href="#static_android.statistics.info.sharpnessMapSize">android.statistics.info.sharpnessMapSize</a> (static)</li>
+ <li><a href="#dynamic_android.statistics.faceDetectMode">android.statistics.faceDetectMode</a> (dynamic)</li>
+ <li><a href="#dynamic_android.statistics.faceIds">android.statistics.faceIds</a> (dynamic)</li>
+ <li><a href="#dynamic_android.statistics.faceLandmarks">android.statistics.faceLandmarks</a> (dynamic)</li>
+ <li><a href="#dynamic_android.statistics.faceRectangles">android.statistics.faceRectangles</a> (dynamic)</li>
+ <li><a href="#dynamic_android.statistics.faceScores">android.statistics.faceScores</a> (dynamic)</li>
+ <li><a href="#dynamic_android.statistics.histogram">android.statistics.histogram</a> (dynamic)</li>
+ <li><a href="#dynamic_android.statistics.histogramMode">android.statistics.histogramMode</a> (dynamic)</li>
+ <li><a href="#dynamic_android.statistics.sharpnessMap">android.statistics.sharpnessMap</a> (dynamic)</li>
+ <li><a href="#dynamic_android.statistics.sharpnessMapMode">android.statistics.sharpnessMapMode</a> (dynamic)</li>
+ </ul>
+ </li> <!-- toc_section -->
+ <li><p class="toc_section"><a href="#section_tonemap">tonemap</a></p>
+ <ul class="toc_section">
+ <li><a href="#controls_android.tonemap.curveBlue">android.tonemap.curveBlue</a> (controls)</li>
+ <li><a href="#controls_android.tonemap.curveGreen">android.tonemap.curveGreen</a> (controls)</li>
+ <li><a href="#controls_android.tonemap.curveRed">android.tonemap.curveRed</a> (controls)</li>
+ <li><a href="#controls_android.tonemap.mode">android.tonemap.mode</a> (controls)</li>
+ <li><a href="#static_android.tonemap.maxCurvePoints">android.tonemap.maxCurvePoints</a> (static)</li>
+ <li><a href="#dynamic_android.tonemap.curveBlue">android.tonemap.curveBlue</a> (dynamic)</li>
+ <li><a href="#dynamic_android.tonemap.curveGreen">android.tonemap.curveGreen</a> (dynamic)</li>
+ <li><a href="#dynamic_android.tonemap.curveRed">android.tonemap.curveRed</a> (dynamic)</li>
+ <li><a href="#dynamic_android.tonemap.mode">android.tonemap.mode</a> (dynamic)</li>
+ </ul>
+ </li> <!-- toc_section -->
+ </ul>
+
+ <h1>Properties</h1>
+ <table class="properties">
+
+ <thead class="thead_dummy">
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead> <!-- so that the first occurrence of thead is not
+ above the first occurrence of tr -->
+<!-- <namespace name="android"> -->
+ <tr><td colspan="7" id="section_colorCorrection" class="section">colorCorrection</td></tr>
+
+
+ <tr><td colspan="7" class="kind">controls</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="controls_android.colorCorrection.mode">
+ <td class="entry_name">android.<wbr>color<wbr>Correction.<wbr>mode</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">TRANSFORM_MATRIX</span>
+ <span class="entry_type_enum_notes">Use the android.<wbr>color<wbr>Correction.<wbr>transform matrix
+ to do color conversion</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">FAST</span>
+ <span class="entry_type_enum_notes">Must not slow down frame rate relative to raw
+ bayer output</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">HIGH_QUALITY</span>
+ <span class="entry_type_enum_notes">Frame rate may be reduced by high
+ quality</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.colorCorrection.transform">
+ <td class="entry_name">android.<wbr>color<wbr>Correction.<wbr>transform</td>
+ <td class="entry_type">
+ <span class="entry_type_name">float</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 3 x 3
+ </span>
+
+ <div class="entry_type_notes">3x3 float matrix in row-major order</div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ A transform matrix to chromatically adapt
+ pixels in the CIE XYZ (1931) color space from the scene
+ illuminant to the sRGB-standard
+ D65-illuminant
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ Output values are expected to be in the range
+ (0,<wbr>1)
+ </td>
+
+ <td class="entry_notes">
+ Values outside (0,<wbr>1) should be clamped.<wbr> Need to
+ provide utilities to go from CCT (+hue?),<wbr> or (x,<wbr>y) white
+ point,<wbr> (or AWB mode) to matrix; use linear Bradford
+ algorithm.<wbr>
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+ <tr><td colspan="7" class="kind">dynamic</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="dynamic_android.colorCorrection.mode">
+ <td class="entry_name">android.<wbr>color<wbr>Correction.<wbr>mode</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">TRANSFORM_MATRIX</span>
+ <span class="entry_type_enum_notes">Use the android.<wbr>color<wbr>Correction.<wbr>transform matrix
+ to do color conversion</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">FAST</span>
+ <span class="entry_type_enum_notes">Must not slow down frame rate relative to raw
+ bayer output</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">HIGH_QUALITY</span>
+ <span class="entry_type_enum_notes">Frame rate may be reduced by high
+ quality</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+
+ <!-- end of section -->
+ <tr><td colspan="7" id="section_control" class="section">control</td></tr>
+
+
+ <tr><td colspan="7" class="kind">controls</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="controls_android.control.aeAntibandingMode">
+ <td class="entry_name">android.<wbr>control.<wbr>ae<wbr>Antibanding<wbr>Mode</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">OFF</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">50HZ</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">60HZ</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">AUTO</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Enum for controlling
+ antibanding
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+
+ android.<wbr>control.<wbr>ae<wbr>Available<wbr>Antibanding<wbr>Modes
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.control.aeExposureCompensation">
+ <td class="entry_name">android.<wbr>control.<wbr>ae<wbr>Exposure<wbr>Compensation</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Adjustment to AE target image
+ brightness
+ </td>
+
+ <td class="entry_units">
+ count of positive/<wbr>negative EV steps
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ For example,<wbr> if EV step is 0.<wbr>333,<wbr> '6' will mean an
+ exposure compensation of +2 EV; -3 will mean an exposure
+ compensation of -1
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.control.aeLock">
+ <td class="entry_name">android.<wbr>control.<wbr>ae<wbr>Lock</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">OFF</span>
+ <span class="entry_type_enum_notes">Autoexposure lock is disabled; the AE algorithm
+ is free to update its parameters.<wbr></span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">ON</span>
+ <span class="entry_type_enum_notes">Autoexposure lock is enabled; the AE algorithm
+ must not update the exposure and sensitivity parameters
+ while the lock is active</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Whether AE is currently locked to its latest
+ calculated values
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ Note that even when AE is locked,<wbr> the flash may be
+ fired if the AE mode is ON_<wbr>AUTO_<wbr>FLASH /<wbr> ON_<wbr>ALWAYS_<wbr>FLASH /<wbr>
+ ON_<wbr>AUTO_<wbr>FLASH_<wbr>REDEYE.<wbr>
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.control.aeMode">
+ <td class="entry_name">android.<wbr>control.<wbr>ae<wbr>Mode</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">OFF</span>
+ <span class="entry_type_enum_notes">Autoexposure is disabled; sensor.<wbr>exposureTime
+ and sensor.<wbr>sensitivity are used</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">ON</span>
+ <span class="entry_type_enum_notes">Autoexposure is active,<wbr> no flash
+ control</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">ON_AUTO_FLASH</span>
+ <span class="entry_type_enum_notes">if flash exists Autoexposure is active,<wbr> auto
+ flash control; flash may be fired when precapture
+ trigger is activated,<wbr> and for captures for which
+ captureIntent = STILL_<wbr>CAPTURE</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">ON_ALWAYS_FLASH</span>
+ <span class="entry_type_enum_notes">if flash exists Autoexposure is active,<wbr> auto
+ flash control for precapture trigger and always flash
+ when captureIntent = STILL_<wbr>CAPTURE</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">ON_AUTO_FLASH_REDEYE</span>
+ <span class="entry_type_enum_notes">optional Automatic red eye reduction with flash.<wbr>
+ If deemed necessary,<wbr> red eye reduction sequence should
+ fire when precapture trigger is activated,<wbr> and final
+ flash should fire when captureIntent =
+ STILL_<wbr>CAPTURE</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Whether AE is currently updating the sensor
+ exposure and sensitivity fields
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ android.<wbr>control.<wbr>ae<wbr>Available<wbr>Modes
+ </td>
+
+ <td class="entry_notes">
+ Only effective if android.<wbr>control.<wbr>mode =
+ AUTO
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.control.aeRegions">
+ <td class="entry_name">android.<wbr>control.<wbr>ae<wbr>Regions</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 5 x area_count
+ </span>
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ List of areas to use for
+ metering
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ Each area is a rectangle plus weight: xmin,<wbr> ymin,<wbr>
+ xmax,<wbr> ymax,<wbr> weight.<wbr> The coordinate system is based on the
+ active pixel array,<wbr> with (0,<wbr>0) being the top-left of the
+ active pixel array,<wbr> and
+ (android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>width,<wbr>
+ android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>height) being the
+ bottom-right point of the active pixel array.<wbr> The weight
+ should be nonnegative.<wbr> If all regions have 0 weight,<wbr> then
+ no specific metering area needs to be used by the HAL.<wbr> If
+ the metering region is outside the current
+ android.<wbr>scaler.<wbr>crop<wbr>Region,<wbr> the HAL should ignore the
+ sections outside the region and output the used sections
+ in the frame metadata
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.control.aeTargetFpsRange">
+ <td class="entry_name">android.<wbr>control.<wbr>ae<wbr>Target<wbr>Fps<wbr>Range</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 2
+ </span>
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Range over which fps can be adjusted to
+ maintain exposure
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ android.<wbr>control.<wbr>ae<wbr>Available<wbr>Target<wbr>Fps<wbr>Ranges
+ </td>
+
+ <td class="entry_notes">
+ Only constrains AE algorithm,<wbr> not manual control
+ of android.<wbr>sensor.<wbr>exposure<wbr>Time
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.control.afMode">
+ <td class="entry_name">android.<wbr>control.<wbr>af<wbr>Mode</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">OFF</span>
+ <span class="entry_type_enum_notes">The 3A routines do not control the lens;
+ android.<wbr>lens.<wbr>focus<wbr>Position is controlled by the
+ application</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">AUTO</span>
+ <span class="entry_type_enum_notes">if lens is not fixed focus.<wbr> Use
+ android.<wbr>lens.<wbr>minimum<wbr>Focus<wbr>Distance to determine if lens
+ is fixed focus In this mode,<wbr> the lens does not move
+ unless the autofocus trigger action is called.<wbr> When
+ that trigger is activated,<wbr> AF must transition to
+ ACTIVE_<wbr>SCAN,<wbr> then to the outcome of the scan (FOCUSED
+ or NOT_<wbr>FOCUSED).<wbr> Triggering cancel AF resets the lens
+ position to default,<wbr> and sets the AF state to
+ INACTIVE.<wbr></span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">MACRO</span>
+ <span class="entry_type_enum_notes">In this mode,<wbr> the lens does not move unless the
+ autofocus trigger action is called.<wbr> When that trigger
+ is activated,<wbr> AF must transition to ACTIVE_<wbr>SCAN,<wbr> then
+ to the outcome of the scan (FOCUSED or NOT_<wbr>FOCUSED).<wbr>
+ Triggering cancel AF resets the lens position to
+ default,<wbr> and sets the AF state to
+ INACTIVE.<wbr></span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">CONTINUOUS_VIDEO</span>
+ <span class="entry_type_enum_notes">In this mode,<wbr> the AF algorithm modifies the lens
+ position continually to attempt to provide a
+ constantly-in-focus image stream.<wbr> The focusing behavior
+ should be suitable for good quality video recording;
+ typically this means slower focus movement and no
+ overshoots.<wbr> When the AF trigger is not involved,<wbr> the AF
+ algorithm should start in INACTIVE state,<wbr> and then
+ transition into PASSIVE_<wbr>SCAN and PASSIVE_<wbr>FOCUSED states
+ as appropriate.<wbr> When the AF trigger is activated,<wbr> the
+ algorithm should immediately transition into AF_<wbr>FOCUSED
+ or AF_<wbr>NOT_<wbr>FOCUSED as appropriate,<wbr> and lock the lens
+ position until a cancel AF trigger is received.<wbr> Once
+ cancel is received,<wbr> the algorithm should transition
+ back to INACTIVE and resume passive scan.<wbr> Note that
+ this behavior is not identical to CONTINUOUS_<wbr>PICTURE,<wbr>
+ since an ongoing PASSIVE_<wbr>SCAN must immediately be
+ canceled.<wbr></span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">CONTINUOUS_PICTURE</span>
+ <span class="entry_type_enum_notes">In this mode,<wbr> the AF algorithm modifies the lens
+ position continually to attempt to provide a
+ constantly-in-focus image stream.<wbr> The focusing behavior
+ should be suitable for still image capture; typically
+ this means focusing as fast as possible.<wbr> When the AF
+ trigger is not involved,<wbr> the AF algorithm should start
+ in INACTIVE state,<wbr> and then transition into
+ PASSIVE_<wbr>SCAN and PASSIVE_<wbr>FOCUSED states as appropriate
+ as it attempts to maintain focus.<wbr> When the AF trigger
+ is activated,<wbr> the algorithm should finish its
+ PASSIVE_<wbr>SCAN if active,<wbr> and then transition into
+ AF_<wbr>FOCUSED or AF_<wbr>NOT_<wbr>FOCUSED as appropriate,<wbr> and lock
+ the lens position until a cancel AF trigger is
+ received.<wbr> When the AF cancel trigger is activated,<wbr> the
+ algorithm should transition back to INACTIVE and then
+ act as if it has just been started.<wbr></span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">EDOF</span>
+ <span class="entry_type_enum_notes">Extended depth of field (digital focus).<wbr> AF
+ trigger is ignored,<wbr> AF state should always be
+ INACTIVE.<wbr></span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Whether AF is currently enabled,<wbr> and what
+ mode it is set to
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.control.afRegions">
+ <td class="entry_name">android.<wbr>control.<wbr>af<wbr>Regions</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 5 x area_count
+ </span>
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ List of areas to use for focus
+ estimation
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ Each area is a rectangle plus weight: xmin,<wbr> ymin,<wbr>
+ xmax,<wbr> ymax,<wbr> weight.<wbr> The coordinate system is based on the
+ active pixel array,<wbr> with (0,<wbr>0) being the top-left of the
+ active pixel array,<wbr> and
+ (android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>width,<wbr>
+ android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>height) being the
+ bottom-right point of the active pixel array.<wbr> The weight
+ should be nonnegative.<wbr> If all regions have 0 weight,<wbr> then
+ no specific focus area needs to be used by the HAL.<wbr> If
+ the focusing region is outside the current
+ android.<wbr>scaler.<wbr>crop<wbr>Region,<wbr> the HAL should ignore the
+ sections outside the region and output the used sections
+ in the frame metadata
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.control.awbLock">
+ <td class="entry_name">android.<wbr>control.<wbr>awb<wbr>Lock</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">OFF</span>
+ <span class="entry_type_enum_notes">Auto-whitebalance lock is disabled; the AWB
+ algorithm is free to update its parameters if in AUTO
+ mode.<wbr></span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">ON</span>
+ <span class="entry_type_enum_notes">Auto-whitebalance lock is enabled; the AWB
+ algorithm must not update the exposure and sensitivity
+ parameters while the lock is active</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Whether AWB is currently locked to its
+ latest calculated values
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ Note that AWB lock is only meaningful for AUTO
+ mode; in other modes,<wbr> AWB is already fixed to a specific
+ setting
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.control.awbMode">
+ <td class="entry_name">android.<wbr>control.<wbr>awb<wbr>Mode</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">OFF</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">AUTO</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">INCANDESCENT</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">FLUORESCENT</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">WARM_FLUORESCENT</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">DAYLIGHT</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">CLOUDY_DAYLIGHT</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">TWILIGHT</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">SHADE</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Whether AWB is currently setting the color
+ transform fields,<wbr> and what its illumination target
+ is
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ [BC - AWB lock,<wbr>AWB modes]
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ <li><a href="#tag_AWB">AWB</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.control.awbRegions">
+ <td class="entry_name">android.<wbr>control.<wbr>awb<wbr>Regions</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 5 x area_count
+ </span>
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ List of areas to use for illuminant
+ estimation
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ Only used in AUTO mode.<wbr> Each area is a rectangle
+ plus weight: xmin,<wbr> ymin,<wbr> xmax,<wbr> ymax,<wbr> weight.<wbr> The
+ coordinate system is based on the active pixel array,<wbr>
+ with (0,<wbr>0) being the top-left of the active pixel array,<wbr>
+ and (android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>width,<wbr>
+ android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>height) being the
+ bottom-right point of the active pixel array.<wbr> The weight
+ should be nonnegative.<wbr> If all regions have 0 weight,<wbr> then
+ no specific metering area needs to be used by the HAL.<wbr> If
+ the metering region is outside the current
+ android.<wbr>scaler.<wbr>crop<wbr>Region,<wbr> the HAL should ignore the
+ sections outside the region and output the used sections
+ in the frame metadata
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.control.captureIntent">
+ <td class="entry_name">android.<wbr>control.<wbr>capture<wbr>Intent</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">CUSTOM</span>
+ <span class="entry_type_enum_notes">This request doesn't fall into the other
+ categories.<wbr> Default to preview-like
+ behavior.<wbr></span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">PREVIEW</span>
+ <span class="entry_type_enum_notes">This request is for a preview-like usecase.<wbr> The
+ precapture trigger may be used to start off a metering
+ w/<wbr>flash sequence</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">STILL_CAPTURE</span>
+ <span class="entry_type_enum_notes">This request is for a still capture-type
+ usecase.<wbr></span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">VIDEO_RECORD</span>
+ <span class="entry_type_enum_notes">This request is for a video recording
+ usecase.<wbr></span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">VIDEO_SNAPSHOT</span>
+ <span class="entry_type_enum_notes">This request is for a video snapshot (still
+ image while recording video) usecase</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">ZERO_SHUTTER_LAG</span>
+ <span class="entry_type_enum_notes">This request is for a ZSL usecase; the
+ application will stream full-resolution images and
+ reprocess one or several later for a final
+ capture</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Information to 3A routines about the purpose
+ of this capture,<wbr> to help decide optimal 3A
+ strategy
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ all must be supported
+ </td>
+
+ <td class="entry_notes">
+ Only used if android.<wbr>control.<wbr>mode != OFF.<wbr>
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.control.effectMode">
+ <td class="entry_name">android.<wbr>control.<wbr>effect<wbr>Mode</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">OFF</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">MONO</span>
+ <span class="entry_type_enum_optional">optional</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">NEGATIVE</span>
+ <span class="entry_type_enum_optional">optional</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">SOLARIZE</span>
+ <span class="entry_type_enum_optional">optional</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">SEPIA</span>
+ <span class="entry_type_enum_optional">optional</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">POSTERIZE</span>
+ <span class="entry_type_enum_optional">optional</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">WHITEBOARD</span>
+ <span class="entry_type_enum_optional">optional</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">BLACKBOARD</span>
+ <span class="entry_type_enum_optional">optional</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">AQUA</span>
+ <span class="entry_type_enum_optional">optional</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Whether any special color effect is in use.<wbr>
+ Only used if android.<wbr>control.<wbr>mode != OFF
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ android.<wbr>control.<wbr>available<wbr>Effects
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.control.mode">
+ <td class="entry_name">android.<wbr>control.<wbr>mode</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">OFF</span>
+ <span class="entry_type_enum_notes">Full application control of pipeline.<wbr> All 3A
+ routines are disabled,<wbr> no other settings in
+ android.<wbr>control.<wbr>* have any effect</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">AUTO</span>
+ <span class="entry_type_enum_notes">Use settings for each individual 3A routine.<wbr>
+ Manual control of capture parameters is disabled.<wbr> All
+ controls in android.<wbr>control.<wbr>* besides sceneMode take
+ effect</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">USE_SCENE_MODE</span>
+ <span class="entry_type_enum_notes">Use specific scene mode.<wbr> Enabling this disables
+ control.<wbr>aeMode,<wbr> control.<wbr>awbMode and control.<wbr>afMode
+ controls; the HAL must ignore those settings while
+ USE_<wbr>SCENE_<wbr>MODE is active (except for FACE_<wbr>PRIORITY
+ scene mode).<wbr> Other control entries are still active.<wbr>
+ This setting can only be used if availableSceneModes !=
+ UNSUPPORTED</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Overall mode of 3A control
+ routines
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ all must be supported
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.control.sceneMode">
+ <td class="entry_name">android.<wbr>control.<wbr>scene<wbr>Mode</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">UNSUPPORTED</span>
+ <span class="entry_type_enum_value">0</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">FACE_PRIORITY</span>
+ <span class="entry_type_enum_notes">if face detection support exists Use face
+ detection data to drive 3A routines.<wbr> If face detection
+ statistics are disabled,<wbr> should still operate correctly
+ (but not return face detection statistics to the
+ framework).<wbr> Unlike the other scene modes,<wbr> aeMode,<wbr>
+ awbMode,<wbr> and afMode remain active when FACE_<wbr>PRIORITY is
+ set.<wbr> This is due to compatibility concerns with the old
+ camera API</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">ACTION</span>
+ <span class="entry_type_enum_optional">optional</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">PORTRAIT</span>
+ <span class="entry_type_enum_optional">optional</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">LANDSCAPE</span>
+ <span class="entry_type_enum_optional">optional</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">NIGHT</span>
+ <span class="entry_type_enum_optional">optional</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">NIGHT_PORTRAIT</span>
+ <span class="entry_type_enum_optional">optional</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">THEATRE</span>
+ <span class="entry_type_enum_optional">optional</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">BEACH</span>
+ <span class="entry_type_enum_optional">optional</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">SNOW</span>
+ <span class="entry_type_enum_optional">optional</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">SUNSET</span>
+ <span class="entry_type_enum_optional">optional</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">STEADYPHOTO</span>
+ <span class="entry_type_enum_optional">optional</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">FIREWORKS</span>
+ <span class="entry_type_enum_optional">optional</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">SPORTS</span>
+ <span class="entry_type_enum_optional">optional</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">PARTY</span>
+ <span class="entry_type_enum_optional">optional</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">CANDLELIGHT</span>
+ <span class="entry_type_enum_optional">optional</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">BARCODE</span>
+ <span class="entry_type_enum_optional">optional</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Which scene mode is active when
+ android.<wbr>control.<wbr>mode = SCENE_<wbr>MODE
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ android.<wbr>control.<wbr>available<wbr>Scene<wbr>Modes
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.control.videoStabilizationMode">
+ <td class="entry_name">android.<wbr>control.<wbr>video<wbr>Stabilization<wbr>Mode</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">OFF</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">ON</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Whether video stabilization is
+ active
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ If enabled,<wbr> video stabilization can modify the
+ android.<wbr>scaler.<wbr>crop<wbr>Region to keep the video stream
+ stabilized
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+ <tr><td colspan="7" class="kind">static</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="static_android.control.aeAvailableAntibandingModes">
+ <td class="entry_name">android.<wbr>control.<wbr>ae<wbr>Available<wbr>Antibanding<wbr>Modes</td>
+ <td class="entry_type">
+ <span class="entry_type_name">byte</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ n
+ </span>
+
+ <div class="entry_type_notes">list of enums</div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Which set of antibanding modes are
+ supported
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.control.aeAvailableModes">
+ <td class="entry_name">android.<wbr>control.<wbr>ae<wbr>Available<wbr>Modes</td>
+ <td class="entry_type">
+ <span class="entry_type_name">byte</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ n
+ </span>
+
+ <div class="entry_type_notes">list of enums</div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Which subset of AE modes is
+ supported
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ OFF,<wbr> ON must be supported.<wbr>
+ ON_<wbr>AUTO_<wbr>FLASH/<wbr>ON_<wbr>ALWAYS_<wbr>FLASH must be supported if flash
+ unit is available
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.control.aeAvailableTargetFpsRanges">
+ <td class="entry_name">android.<wbr>control.<wbr>ae<wbr>Available<wbr>Target<wbr>Fps<wbr>Ranges</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 2 x n
+ </span>
+
+ <div class="entry_type_notes">list of pairs of frame rates</div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ List of frame rate ranges supported by the
+ AE algorithm/<wbr>hardware
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.control.aeCompensationRange">
+ <td class="entry_name">android.<wbr>control.<wbr>ae<wbr>Compensation<wbr>Range</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 2
+ </span>
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Maximum and minimum exposure compensation
+ setting,<wbr> in counts of
+ android.<wbr>control.<wbr>ae<wbr>Compensation<wbr>Step<wbr>Size
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ At least (-2,<wbr>2)/<wbr>(exp compensation step
+ size)
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.control.aeCompensationStep">
+ <td class="entry_name">android.<wbr>control.<wbr>ae<wbr>Compensation<wbr>Step</td>
+ <td class="entry_type">
+ <span class="entry_type_name">rational</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Smallest step by which exposure compensation
+ can be changed
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ <= 1/<wbr>2
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.control.afAvailableModes">
+ <td class="entry_name">android.<wbr>control.<wbr>af<wbr>Available<wbr>Modes</td>
+ <td class="entry_type">
+ <span class="entry_type_name">byte</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ n
+ </span>
+
+ <div class="entry_type_notes">List of enums</div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ List of AF modes that can be
+ selected
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ OFF must be included.<wbr> AUTO must be supported if
+ lens allows for changing focus
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.control.availableEffects">
+ <td class="entry_name">android.<wbr>control.<wbr>available<wbr>Effects</td>
+ <td class="entry_type">
+ <span class="entry_type_name">byte</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ n
+ </span>
+
+ <div class="entry_type_notes">list of enums</div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ what subset of the full color effect enum
+ list is supported
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ OFF must be listed
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.control.availableSceneModes">
+ <td class="entry_name">android.<wbr>control.<wbr>available<wbr>Scene<wbr>Modes</td>
+ <td class="entry_type">
+ <span class="entry_type_name">byte</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ n
+ </span>
+
+ <div class="entry_type_notes">list of enums from android.<wbr>control.<wbr>scene<wbr>Mode,<wbr> plus UNSUPPORTED to indicate no scene modes are supported</div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ what subset of the scene mode enum list is
+ supported.<wbr>
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ SCENE_<wbr>MODE_<wbr>FACE_<wbr>PRIORITY must be supported if face
+ detection is supported
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.control.availableVideoStabilizationModes">
+ <td class="entry_name">android.<wbr>control.<wbr>available<wbr>Video<wbr>Stabilization<wbr>Modes</td>
+ <td class="entry_type">
+ <span class="entry_type_name">byte</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ n
+ </span>
+
+ <div class="entry_type_notes">List of enums.<wbr></div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ List of video stabilization modes that can
+ be supported
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ OFF must be included
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.control.awbAvailableModes">
+ <td class="entry_name">android.<wbr>control.<wbr>awb<wbr>Available<wbr>Modes</td>
+ <td class="entry_type">
+ <span class="entry_type_name">byte</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ </td>
+
+ <td class="entry_units">
+ List of enums (android.<wbr>control.<wbr>awb<wbr>Mode)
+ </td>
+
+ <td class="entry_range">
+ OFF,<wbr> AUTO must be included
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.control.maxRegions">
+ <td class="entry_name">android.<wbr>control.<wbr>max<wbr>Regions</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ For AE,<wbr> AWB,<wbr> and AF,<wbr> how many individual
+ regions can be listed for metering?
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ >= 1
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.control.sceneModeOverrides">
+ <td class="entry_name">android.<wbr>control.<wbr>scene<wbr>Mode<wbr>Overrides</td>
+ <td class="entry_type">
+ <span class="entry_type_name">byte</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 3 x lengthavailablescenemodes
+ </span>
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ List of AE,<wbr> AWB,<wbr> and AF modes to use for
+ each available scene mode
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ For each listed scene mode,<wbr> lists the aeMode,<wbr>
+ awbMode,<wbr> and afMode that the HAL wants to use for that
+ scene mode.<wbr> For each entry,<wbr> the order is {aeMode,<wbr>
+ awbMode,<wbr> afMode} in order of increasing index
+ </td>
+
+ <td class="entry_notes">
+ When a scene mode is enabled,<wbr> the HAL is expected
+ to override aeMode,<wbr> awbMode,<wbr> and afMode with its
+ preferred settings for that scene mode.<wbr> To simplify
+ communication with old camera API applications,<wbr> the
+ service wants this override list in the static metadata.<wbr>
+ The order of this list matches that of
+ availableSceneModes,<wbr> with 3 entires for each scene mode.<wbr>
+ The overrides listed for SCENE_<wbr>MODE_<wbr>FACE_<wbr>PRIORITY are
+ ignored,<wbr> since for that mode,<wbr> the application-set aeMode,<wbr>
+ awbMode,<wbr> and afMode are used instead,<wbr> like they are when
+ android.<wbr>control.<wbr>mode is AUTO.<wbr> It is recommended that for
+ FACE_<wbr>PRIORITY,<wbr> the overrides should be set to 0.<wbr> As an
+ example,<wbr> if availableSceneModes is { FACE_<wbr>PRIORITY,<wbr>
+ ACTION,<wbr> NIGHT },<wbr> then the service expects this field to
+ have 9 entries; for example { 0 ,<wbr> 0,<wbr> 0,<wbr> ON_<wbr>AUTO_<wbr>FLASH,<wbr>
+ AUTO,<wbr> CONTINUOUS_<wbr>PICTURE,<wbr> ON_<wbr>AUTO_<wbr>FLASH,<wbr> INCANDESCENT,<wbr>
+ AUTO }
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+ <tr><td colspan="7" class="kind">dynamic</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="dynamic_android.control.aePrecaptureId">
+ <td class="entry_name">android.<wbr>control.<wbr>ae<wbr>Precapture<wbr>Id</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ The ID sent with the latest
+ CAMERA2_<wbr>TRIGGER_<wbr>PRECAPTURE_<wbr>METERING call
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ Must be 0 if no
+ CAMERA2_<wbr>TRIGGER_<wbr>PRECAPTURE_<wbr>METERING trigger received yet
+ by HAL.<wbr> Always updated even if AE algorithm ignores the
+ trigger
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.control.aeRegions">
+ <td class="entry_name">android.<wbr>control.<wbr>ae<wbr>Regions</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 5 x area_count
+ </span>
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ List of areas to use for
+ metering
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ Each area is a rectangle plus weight: xmin,<wbr> ymin,<wbr>
+ xmax,<wbr> ymax,<wbr> weight.<wbr> The coordinate system is based on the
+ active pixel array,<wbr> with (0,<wbr>0) being the top-left of the
+ active pixel array,<wbr> and
+ (android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>width,<wbr>
+ android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>height) being the
+ bottom-right point of the active pixel array.<wbr> The weight
+ should be nonnegative.<wbr> If all regions have 0 weight,<wbr> then
+ no specific metering area needs to be used by the HAL.<wbr> If
+ the metering region is outside the current
+ android.<wbr>scaler.<wbr>crop<wbr>Region,<wbr> the HAL should ignore the
+ sections outside the region and output the used sections
+ in the frame metadata
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.control.aeState">
+ <td class="entry_name">android.<wbr>control.<wbr>ae<wbr>State</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">INACTIVE</span>
+ <span class="entry_type_enum_notes">AE is off</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">SEARCHING</span>
+ <span class="entry_type_enum_notes">AE doesn't yet have a good set of control values
+ for the current scene</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">CONVERGED</span>
+ <span class="entry_type_enum_notes">AE has a good set of control values for the
+ current scene</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">LOCKED</span>
+ <span class="entry_type_enum_notes">AE has been locked (aeMode =
+ LOCKED)</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">FLASH_REQUIRED</span>
+ <span class="entry_type_enum_notes">AE has a good set of control values,<wbr> but flash
+ needs to be fired for good quality still
+ capture</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">PRECAPTURE</span>
+ <span class="entry_type_enum_notes">AE has been asked to do a precapture sequence
+ (through the
+ trigger_<wbr>action(CAMERA2_<wbr>TRIGGER_<wbr>PRECAPTURE_<wbr>METERING)
+ call),<wbr> and is currently executing it.<wbr> Once PRECAPTURE
+ completes,<wbr> AE will transition to CONVERGED or
+ FLASH_<wbr>REQUIRED as appropriate</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Current state of AE algorithm
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ Whenever the AE algorithm state changes,<wbr> a
+ MSG_<wbr>AUTOEXPOSURE notification must be send if a
+ notification callback is registered.<wbr>
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.control.afMode">
+ <td class="entry_name">android.<wbr>control.<wbr>af<wbr>Mode</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">OFF</span>
+ <span class="entry_type_enum_notes">The 3A routines do not control the lens;
+ android.<wbr>lens.<wbr>focus<wbr>Position is controlled by the
+ application</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">AUTO</span>
+ <span class="entry_type_enum_notes">if lens is not fixed focus.<wbr> Use
+ android.<wbr>lens.<wbr>minimum<wbr>Focus<wbr>Distance to determine if lens
+ is fixed focus In this mode,<wbr> the lens does not move
+ unless the autofocus trigger action is called.<wbr> When
+ that trigger is activated,<wbr> AF must transition to
+ ACTIVE_<wbr>SCAN,<wbr> then to the outcome of the scan (FOCUSED
+ or NOT_<wbr>FOCUSED).<wbr> Triggering cancel AF resets the lens
+ position to default,<wbr> and sets the AF state to
+ INACTIVE.<wbr></span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">MACRO</span>
+ <span class="entry_type_enum_notes">In this mode,<wbr> the lens does not move unless the
+ autofocus trigger action is called.<wbr> When that trigger
+ is activated,<wbr> AF must transition to ACTIVE_<wbr>SCAN,<wbr> then
+ to the outcome of the scan (FOCUSED or NOT_<wbr>FOCUSED).<wbr>
+ Triggering cancel AF resets the lens position to
+ default,<wbr> and sets the AF state to
+ INACTIVE.<wbr></span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">CONTINUOUS_VIDEO</span>
+ <span class="entry_type_enum_notes">In this mode,<wbr> the AF algorithm modifies the lens
+ position continually to attempt to provide a
+ constantly-in-focus image stream.<wbr> The focusing behavior
+ should be suitable for good quality video recording;
+ typically this means slower focus movement and no
+ overshoots.<wbr> When the AF trigger is not involved,<wbr> the AF
+ algorithm should start in INACTIVE state,<wbr> and then
+ transition into PASSIVE_<wbr>SCAN and PASSIVE_<wbr>FOCUSED states
+ as appropriate.<wbr> When the AF trigger is activated,<wbr> the
+ algorithm should immediately transition into AF_<wbr>FOCUSED
+ or AF_<wbr>NOT_<wbr>FOCUSED as appropriate,<wbr> and lock the lens
+ position until a cancel AF trigger is received.<wbr> Once
+ cancel is received,<wbr> the algorithm should transition
+ back to INACTIVE and resume passive scan.<wbr> Note that
+ this behavior is not identical to CONTINUOUS_<wbr>PICTURE,<wbr>
+ since an ongoing PASSIVE_<wbr>SCAN must immediately be
+ canceled.<wbr></span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">CONTINUOUS_PICTURE</span>
+ <span class="entry_type_enum_notes">In this mode,<wbr> the AF algorithm modifies the lens
+ position continually to attempt to provide a
+ constantly-in-focus image stream.<wbr> The focusing behavior
+ should be suitable for still image capture; typically
+ this means focusing as fast as possible.<wbr> When the AF
+ trigger is not involved,<wbr> the AF algorithm should start
+ in INACTIVE state,<wbr> and then transition into
+ PASSIVE_<wbr>SCAN and PASSIVE_<wbr>FOCUSED states as appropriate
+ as it attempts to maintain focus.<wbr> When the AF trigger
+ is activated,<wbr> the algorithm should finish its
+ PASSIVE_<wbr>SCAN if active,<wbr> and then transition into
+ AF_<wbr>FOCUSED or AF_<wbr>NOT_<wbr>FOCUSED as appropriate,<wbr> and lock
+ the lens position until a cancel AF trigger is
+ received.<wbr> When the AF cancel trigger is activated,<wbr> the
+ algorithm should transition back to INACTIVE and then
+ act as if it has just been started.<wbr></span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">EDOF</span>
+ <span class="entry_type_enum_notes">Extended depth of field (digital focus).<wbr> AF
+ trigger is ignored,<wbr> AF state should always be
+ INACTIVE.<wbr></span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Whether AF is currently enabled,<wbr> and what
+ mode it is set to
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.control.afRegions">
+ <td class="entry_name">android.<wbr>control.<wbr>af<wbr>Regions</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 5 x area_count
+ </span>
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ List of areas to use for focus
+ estimation
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ Each area is a rectangle plus weight: xmin,<wbr> ymin,<wbr>
+ xmax,<wbr> ymax,<wbr> weight.<wbr> The coordinate system is based on the
+ active pixel array,<wbr> with (0,<wbr>0) being the top-left of the
+ active pixel array,<wbr> and
+ (android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>width,<wbr>
+ android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>height) being the
+ bottom-right point of the active pixel array.<wbr> The weight
+ should be nonnegative.<wbr> If all regions have 0 weight,<wbr> then
+ no specific focus area needs to be used by the HAL.<wbr> If
+ the focusing region is outside the current
+ android.<wbr>scaler.<wbr>crop<wbr>Region,<wbr> the HAL should ignore the
+ sections outside the region and output the used sections
+ in the frame metadata
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.control.afState">
+ <td class="entry_name">android.<wbr>control.<wbr>af<wbr>State</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">INACTIVE</span>
+ <span class="entry_type_enum_notes">AF off or has not yet tried to scan/<wbr>been asked
+ to scan</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">PASSIVE_SCAN</span>
+ <span class="entry_type_enum_notes">if CONTINUOUS_<wbr>* modes are supported AF is
+ currently doing an AF scan initiated by a continuous
+ autofocus mode</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">PASSIVE_FOCUSED</span>
+ <span class="entry_type_enum_notes">if CONTINUOUS_<wbr>* modes are supported AF currently
+ believes it is in focus,<wbr> but may restart scanning at
+ any time.<wbr></span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">ACTIVE_SCAN</span>
+ <span class="entry_type_enum_notes">if AUTO or MACRO modes are supported AF is doing
+ an AF scan because it was triggered by AF
+ trigger</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">FOCUSED_LOCKED</span>
+ <span class="entry_type_enum_notes">if any AF mode besides OFF is supported AF
+ believes it is focused correctly and is
+ locked</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">NOT_FOCUSED_LOCKED</span>
+ <span class="entry_type_enum_notes">if any AF mode besides OFF is supported AF has
+ failed to focus successfully and is
+ locked</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Current state of AF algorithm
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ Whenever the AF algorithm state changes,<wbr> a
+ MSG_<wbr>AUTOFOCUS notification must be send if a notification
+ callback is registered.<wbr>
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.control.afTriggerId">
+ <td class="entry_name">android.<wbr>control.<wbr>af<wbr>Trigger<wbr>Id</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ The ID sent with the latest
+ CAMERA2_<wbr>TRIGGER_<wbr>AUTOFOCUS call
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ Must be 0 if no CAMERA2_<wbr>TRIGGER_<wbr>AUTOFOCUS trigger
+ received yet by HAL.<wbr> Always updated even if AF algorithm
+ ignores the trigger
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.control.awbMode">
+ <td class="entry_name">android.<wbr>control.<wbr>awb<wbr>Mode</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">OFF</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">AUTO</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">INCANDESCENT</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">FLUORESCENT</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">WARM_FLUORESCENT</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">DAYLIGHT</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">CLOUDY_DAYLIGHT</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">TWILIGHT</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">SHADE</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Whether AWB is currently setting the color
+ transform fields,<wbr> and what its illumination target
+ is
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ [BC - AWB lock,<wbr>AWB modes]
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ <li><a href="#tag_AWB">AWB</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.control.awbRegions">
+ <td class="entry_name">android.<wbr>control.<wbr>awb<wbr>Regions</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 5 x area_count
+ </span>
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ List of areas to use for illuminant
+ estimation
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ Only used in AUTO mode.<wbr> Each area is a rectangle
+ plus weight: xmin,<wbr> ymin,<wbr> xmax,<wbr> ymax,<wbr> weight.<wbr> The
+ coordinate system is based on the active pixel array,<wbr>
+ with (0,<wbr>0) being the top-left of the active pixel array,<wbr>
+ and (android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>width,<wbr>
+ android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>height) being the
+ bottom-right point of the active pixel array.<wbr> The weight
+ should be nonnegative.<wbr> If all regions have 0 weight,<wbr> then
+ no specific metering area needs to be used by the HAL.<wbr> If
+ the metering region is outside the current
+ android.<wbr>scaler.<wbr>crop<wbr>Region,<wbr> the HAL should ignore the
+ sections outside the region and output the used sections
+ in the frame metadata
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.control.awbState">
+ <td class="entry_name">android.<wbr>control.<wbr>awb<wbr>State</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">INACTIVE</span>
+ <span class="entry_type_enum_notes">AWB is not in auto mode</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">SEARCHING</span>
+ <span class="entry_type_enum_notes">AWB doesn't yet have a good set of control
+ values for the current scene</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">CONVERGED</span>
+ <span class="entry_type_enum_notes">AWB has a good set of control values for the
+ current scene</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">LOCKED</span>
+ <span class="entry_type_enum_notes">AE has been locked (aeMode =
+ LOCKED)</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Current state of AWB algorithm
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ Whenever the AWB algorithm state changes,<wbr> a
+ MSG_<wbr>AUTOWHITEBALANCE notification must be send if a
+ notification callback is registered.<wbr>
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.control.mode">
+ <td class="entry_name">android.<wbr>control.<wbr>mode</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">OFF</span>
+ <span class="entry_type_enum_notes">Full application control of pipeline.<wbr> All 3A
+ routines are disabled,<wbr> no other settings in
+ android.<wbr>control.<wbr>* have any effect</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">AUTO</span>
+ <span class="entry_type_enum_notes">Use settings for each individual 3A routine.<wbr>
+ Manual control of capture parameters is disabled.<wbr> All
+ controls in android.<wbr>control.<wbr>* besides sceneMode take
+ effect</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">USE_SCENE_MODE</span>
+ <span class="entry_type_enum_notes">Use specific scene mode.<wbr> Enabling this disables
+ control.<wbr>aeMode,<wbr> control.<wbr>awbMode and control.<wbr>afMode
+ controls; the HAL must ignore those settings while
+ USE_<wbr>SCENE_<wbr>MODE is active (except for FACE_<wbr>PRIORITY
+ scene mode).<wbr> Other control entries are still active.<wbr>
+ This setting can only be used if availableSceneModes !=
+ UNSUPPORTED</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Overall mode of 3A control
+ routines
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ all must be supported
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+
+ <!-- end of section -->
+ <tr><td colspan="7" id="section_demosaic" class="section">demosaic</td></tr>
+
+
+ <tr><td colspan="7" class="kind">controls</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="controls_android.demosaic.mode">
+ <td class="entry_name">android.<wbr>demosaic.<wbr>mode</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">FAST</span>
+ <span class="entry_type_enum_notes">Minimal or no slowdown of frame rate compared to
+ Bayer RAW output</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">HIGH_QUALITY</span>
+ <span class="entry_type_enum_notes">High-quality may reduce output frame
+ rate</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Controls the quality of the demosaicing
+ processing
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+
+ <!-- end of section -->
+ <tr><td colspan="7" id="section_edge" class="section">edge</td></tr>
+
+
+ <tr><td colspan="7" class="kind">controls</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="controls_android.edge.mode">
+ <td class="entry_name">android.<wbr>edge.<wbr>mode</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">OFF</span>
+ <span class="entry_type_enum_notes">No edge enhancement is applied</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">FAST</span>
+ <span class="entry_type_enum_notes">Must not slow down frame rate relative to raw
+ bayer output</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">HIGH_QUALITY</span>
+ <span class="entry_type_enum_notes">Frame rate may be reduced by high
+ quality</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Operation mode for edge
+ enhancement
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.edge.strength">
+ <td class="entry_name">android.<wbr>edge.<wbr>strength</td>
+ <td class="entry_type">
+ <span class="entry_type_name">byte</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Control the amount of edge enhancement
+ applied to the images
+ </td>
+
+ <td class="entry_units">
+ 1-10; 10 is maximum sharpening
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+ <tr><td colspan="7" class="kind">dynamic</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="dynamic_android.edge.mode">
+ <td class="entry_name">android.<wbr>edge.<wbr>mode</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">OFF</span>
+ <span class="entry_type_enum_notes">No edge enhancement is applied</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">FAST</span>
+ <span class="entry_type_enum_notes">Must not slow down frame rate relative to raw
+ bayer output</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">HIGH_QUALITY</span>
+ <span class="entry_type_enum_notes">Frame rate may be reduced by high
+ quality</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Operation mode for edge
+ enhancement
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+
+ <!-- end of section -->
+ <tr><td colspan="7" id="section_flash" class="section">flash</td></tr>
+
+
+ <tr><td colspan="7" class="kind">controls</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="controls_android.flash.firingPower">
+ <td class="entry_name">android.<wbr>flash.<wbr>firing<wbr>Power</td>
+ <td class="entry_type">
+ <span class="entry_type_name">byte</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Power for flash firing/<wbr>torch
+ </td>
+
+ <td class="entry_units">
+ 10 is max power; 0 is no flash.<wbr> Linear
+ </td>
+
+ <td class="entry_range">
+ 0 - 10
+ </td>
+
+ <td class="entry_notes">
+ Power for snapshot may use a different scale than
+ for torch mode.<wbr> Only one entry for torch mode will be
+ used
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.flash.firingTime">
+ <td class="entry_name">android.<wbr>flash.<wbr>firing<wbr>Time</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int64</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Firing time of flash relative to start of
+ exposure
+ </td>
+
+ <td class="entry_units">
+ nanoseconds
+ </td>
+
+ <td class="entry_range">
+ 0-(exposure time-flash duration)
+ </td>
+
+ <td class="entry_notes">
+ Clamped to (0,<wbr> exposure time - flash
+ duration).<wbr>
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.flash.mode">
+ <td class="entry_name">android.<wbr>flash.<wbr>mode</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">OFF</span>
+ <span class="entry_type_enum_notes">Do not fire the flash for this
+ capture</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">SINGLE</span>
+ <span class="entry_type_enum_notes">if android.<wbr>flash.<wbr>available is true Fire flash
+ for this capture based on firingPower,<wbr>
+ firingTime.<wbr></span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">TORCH</span>
+ <span class="entry_type_enum_notes">if android.<wbr>flash.<wbr>available is true Flash
+ continuously on,<wbr> power set by
+ firingPower</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Select flash operation mode
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+ <tr><td colspan="7" class="kind">static</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="static_android.flash.info.available">
+ <td class="entry_name">android.<wbr>flash.<wbr>info.<wbr>available</td>
+ <td class="entry_type">
+ <span class="entry_type_name">byte</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Whether this camera has a
+ flash
+ </td>
+
+ <td class="entry_units">
+ boolean (0 = false,<wbr> otherwise true)
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ If no flash,<wbr> none of the flash controls do
+ anything.<wbr> All other metadata should return 0
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.flash.info.chargeDuration">
+ <td class="entry_name">android.<wbr>flash.<wbr>info.<wbr>charge<wbr>Duration</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int64</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Time taken before flash can fire
+ again
+ </td>
+
+ <td class="entry_units">
+ nanoseconds
+ </td>
+
+ <td class="entry_range">
+ 0-1e9
+ </td>
+
+ <td class="entry_notes">
+ 1 second too long/<wbr>too short for recharge? Should
+ this be power-dependent?
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+
+
+ <tr class="entry" id="static_android.flash.colorTemperature">
+ <td class="entry_name">android.<wbr>flash.<wbr>color<wbr>Temperature</td>
+ <td class="entry_type">
+ <span class="entry_type_name">byte</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ The x,<wbr>y whitepoint of the
+ flash
+ </td>
+
+ <td class="entry_units">
+ pair of floats
+ </td>
+
+ <td class="entry_range">
+ 0-1 for both
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_ADV">ADV</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.flash.maxEnergy">
+ <td class="entry_name">android.<wbr>flash.<wbr>max<wbr>Energy</td>
+ <td class="entry_type">
+ <span class="entry_type_name">byte</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Max energy output of the flash for a full
+ power single flash
+ </td>
+
+ <td class="entry_units">
+ lumen-seconds
+ </td>
+
+ <td class="entry_range">
+ >= 0
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_ADV">ADV</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+ <tr><td colspan="7" class="kind">dynamic</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="dynamic_android.flash.firingPower">
+ <td class="entry_name">android.<wbr>flash.<wbr>firing<wbr>Power</td>
+ <td class="entry_type">
+ <span class="entry_type_name">byte</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Power for flash firing/<wbr>torch
+ </td>
+
+ <td class="entry_units">
+ 10 is max power; 0 is no flash.<wbr> Linear
+ </td>
+
+ <td class="entry_range">
+ 0 - 10
+ </td>
+
+ <td class="entry_notes">
+ Power for snapshot may use a different scale than
+ for torch mode.<wbr> Only one entry for torch mode will be
+ used
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.flash.firingTime">
+ <td class="entry_name">android.<wbr>flash.<wbr>firing<wbr>Time</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int64</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Firing time of flash relative to start of
+ exposure
+ </td>
+
+ <td class="entry_units">
+ nanoseconds
+ </td>
+
+ <td class="entry_range">
+ 0-(exposure time-flash duration)
+ </td>
+
+ <td class="entry_notes">
+ Clamped to (0,<wbr> exposure time - flash
+ duration).<wbr>
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.flash.mode">
+ <td class="entry_name">android.<wbr>flash.<wbr>mode</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">OFF</span>
+ <span class="entry_type_enum_notes">Do not fire the flash for this
+ capture</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">SINGLE</span>
+ <span class="entry_type_enum_notes">if android.<wbr>flash.<wbr>available is true Fire flash
+ for this capture based on firingPower,<wbr>
+ firingTime.<wbr></span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">TORCH</span>
+ <span class="entry_type_enum_notes">if android.<wbr>flash.<wbr>available is true Flash
+ continuously on,<wbr> power set by
+ firingPower</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Select flash operation mode
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.flash.state">
+ <td class="entry_name">android.<wbr>flash.<wbr>state</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">UNAVAILABLE</span>
+ <span class="entry_type_enum_notes">No flash on camera</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">CHARGING</span>
+ <span class="entry_type_enum_notes">if android.<wbr>flash.<wbr>available is true Flash is
+ charging and cannot be fired</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">READY</span>
+ <span class="entry_type_enum_notes">if android.<wbr>flash.<wbr>available is true Flash is
+ ready to fire</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">FIRED</span>
+ <span class="entry_type_enum_notes">if android.<wbr>flash.<wbr>available is true Flash fired
+ for this capture</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Current state of the flash
+ unit
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+
+ <!-- end of section -->
+ <tr><td colspan="7" id="section_geometric" class="section">geometric</td></tr>
+
+
+ <tr><td colspan="7" class="kind">controls</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="controls_android.geometric.mode">
+ <td class="entry_name">android.<wbr>geometric.<wbr>mode</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">OFF</span>
+ <span class="entry_type_enum_notes">No geometric correction is
+ applied</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">FAST</span>
+ <span class="entry_type_enum_notes">Must not slow down frame rate relative to raw
+ bayer output</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">HIGH_QUALITY</span>
+ <span class="entry_type_enum_notes">Frame rate may be reduced by high
+ quality</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Operating mode of geometric
+ correction
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.geometric.strength">
+ <td class="entry_name">android.<wbr>geometric.<wbr>strength</td>
+ <td class="entry_type">
+ <span class="entry_type_name">byte</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Control the amount of shading correction
+ applied to the images
+ </td>
+
+ <td class="entry_units">
+ unitless: 1-10; 10 is full shading
+ compensation
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_ADV">ADV</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+
+ <!-- end of section -->
+ <tr><td colspan="7" id="section_hotPixel" class="section">hotPixel</td></tr>
+
+
+ <tr><td colspan="7" class="kind">controls</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="controls_android.hotPixel.mode">
+ <td class="entry_name">android.<wbr>hot<wbr>Pixel.<wbr>mode</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">OFF</span>
+ <span class="entry_type_enum_notes">No hot pixel correction can be
+ applied</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">FAST</span>
+ <span class="entry_type_enum_notes">Frame rate must not be reduced compared to raw
+ Bayer output</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">HIGH_QUALITY</span>
+ <span class="entry_type_enum_notes">Frame rate may be reduced by high
+ quality</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Set operational mode for hot pixel
+ correction
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+ <tr><td colspan="7" class="kind">static</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="static_android.hotPixel.info.map">
+ <td class="entry_name">android.<wbr>hot<wbr>Pixel.<wbr>info.<wbr>map</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 2 x n
+ </span>
+
+ <div class="entry_type_notes">list of coordinates based on android.<wbr>sensor.<wbr>pixel<wbr>Array<wbr>Size</div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Location of hot/<wbr>defective pixels on
+ sensor
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_ADV">ADV</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+
+
+
+ <!-- end of kind -->
+ </tbody>
+ <tr><td colspan="7" class="kind">dynamic</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="dynamic_android.hotPixel.mode">
+ <td class="entry_name">android.<wbr>hot<wbr>Pixel.<wbr>mode</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">OFF</span>
+ <span class="entry_type_enum_notes">No hot pixel correction can be
+ applied</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">FAST</span>
+ <span class="entry_type_enum_notes">Frame rate must not be reduced compared to raw
+ Bayer output</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">HIGH_QUALITY</span>
+ <span class="entry_type_enum_notes">Frame rate may be reduced by high
+ quality</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Set operational mode for hot pixel
+ correction
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+
+ <!-- end of section -->
+ <tr><td colspan="7" id="section_jpeg" class="section">jpeg</td></tr>
+
+
+ <tr><td colspan="7" class="kind">controls</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="controls_android.jpeg.gpsCoordinates">
+ <td class="entry_name">android.<wbr>jpeg.<wbr>gps<wbr>Coordinates</td>
+ <td class="entry_type">
+ <span class="entry_type_name">double</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 3
+ </span>
+
+ <div class="entry_type_notes">latitude,<wbr> longitude,<wbr> altitude.<wbr> First two in degrees,<wbr> the third in meters</div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ GPS coordinates to include in output JPEG
+ EXIF
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ (-180 - 180],<wbr> [-90,<wbr>90],<wbr> [-inf,<wbr> inf]
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.jpeg.gpsProcessingMethod">
+ <td class="entry_name">android.<wbr>jpeg.<wbr>gps<wbr>Processing<wbr>Method</td>
+ <td class="entry_type">
+ <span class="entry_type_name">byte</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ 32 characters describing GPS algorithm to
+ include in EXIF
+ </td>
+
+ <td class="entry_units">
+ UTF-8 null-terminated string
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.jpeg.gpsTimestamp">
+ <td class="entry_name">android.<wbr>jpeg.<wbr>gps<wbr>Timestamp</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int64</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Time GPS fix was made to include in
+ EXIF
+ </td>
+
+ <td class="entry_units">
+ UTC in seconds since January 1,<wbr> 1970
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.jpeg.orientation">
+ <td class="entry_name">android.<wbr>jpeg.<wbr>orientation</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Orientation of JPEG image to
+ write
+ </td>
+
+ <td class="entry_units">
+ Degrees in multiples of 90
+ </td>
+
+ <td class="entry_range">
+ 0,<wbr> 90,<wbr> 180,<wbr> 270
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.jpeg.quality">
+ <td class="entry_name">android.<wbr>jpeg.<wbr>quality</td>
+ <td class="entry_type">
+ <span class="entry_type_name">byte</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Compression quality of the final JPEG
+ image
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ 1-100; larger is higher quality
+ </td>
+
+ <td class="entry_notes">
+ 85-95 is typical usage range
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.jpeg.thumbnailQuality">
+ <td class="entry_name">android.<wbr>jpeg.<wbr>thumbnail<wbr>Quality</td>
+ <td class="entry_type">
+ <span class="entry_type_name">byte</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Compression quality of JPEG
+ thumbnail
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ 1-100; larger is higher quality
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.jpeg.thumbnailSize">
+ <td class="entry_name">android.<wbr>jpeg.<wbr>thumbnail<wbr>Size</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 2
+ </span>
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Resolution of embedded JPEG
+ thumbnail
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ from android.<wbr>jpeg.<wbr>available<wbr>Thumbnail<wbr>Sizes
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+ <tr><td colspan="7" class="kind">static</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="static_android.jpeg.availableThumbnailSizes">
+ <td class="entry_name">android.<wbr>jpeg.<wbr>available<wbr>Thumbnail<wbr>Sizes</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 2 x n
+ </span>
+
+ <div class="entry_type_notes">list of resolution pairs</div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Supported resolutions for the JPEG
+ thumbnail
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ Must include at least one valid resolution,<wbr> plus
+ (0,<wbr>0) for no thumbnail generation
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.jpeg.maxSize">
+ <td class="entry_name">android.<wbr>jpeg.<wbr>max<wbr>Size</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Maximum size in bytes for the compressed
+ JPEG buffer
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ Must be large enough to fit any JPEG produced by
+ the camera
+ </td>
+
+ <td class="entry_notes">
+ This is used for sizing the gralloc buffers for
+ JPEG
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+ <tr><td colspan="7" class="kind">dynamic</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="dynamic_android.jpeg.gpsCoordinates">
+ <td class="entry_name">android.<wbr>jpeg.<wbr>gps<wbr>Coordinates</td>
+ <td class="entry_type">
+ <span class="entry_type_name">double</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 3
+ </span>
+
+ <div class="entry_type_notes">latitude,<wbr> longitude,<wbr> altitude.<wbr> First two in degrees,<wbr> the third in meters</div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ GPS coordinates to include in output JPEG
+ EXIF
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ (-180 - 180],<wbr> [-90,<wbr>90],<wbr> [-inf,<wbr> inf]
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.jpeg.gpsProcessingMethod">
+ <td class="entry_name">android.<wbr>jpeg.<wbr>gps<wbr>Processing<wbr>Method</td>
+ <td class="entry_type">
+ <span class="entry_type_name">byte</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ 32 characters describing GPS algorithm to
+ include in EXIF
+ </td>
+
+ <td class="entry_units">
+ UTF-8 null-terminated string
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.jpeg.gpsTimestamp">
+ <td class="entry_name">android.<wbr>jpeg.<wbr>gps<wbr>Timestamp</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int64</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Time GPS fix was made to include in
+ EXIF
+ </td>
+
+ <td class="entry_units">
+ UTC in seconds since January 1,<wbr> 1970
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.jpeg.orientation">
+ <td class="entry_name">android.<wbr>jpeg.<wbr>orientation</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Orientation of JPEG image to
+ write
+ </td>
+
+ <td class="entry_units">
+ Degrees in multiples of 90
+ </td>
+
+ <td class="entry_range">
+ 0,<wbr> 90,<wbr> 180,<wbr> 270
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.jpeg.quality">
+ <td class="entry_name">android.<wbr>jpeg.<wbr>quality</td>
+ <td class="entry_type">
+ <span class="entry_type_name">byte</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Compression quality of the final JPEG
+ image
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ 1-100; larger is higher quality
+ </td>
+
+ <td class="entry_notes">
+ 85-95 is typical usage range
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.jpeg.size">
+ <td class="entry_name">android.<wbr>jpeg.<wbr>size</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ The size of the compressed JPEG image,<wbr> in
+ bytes
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ >= 0
+ </td>
+
+ <td class="entry_notes">
+ If no JPEG output is produced for the request,<wbr>
+ this must be 0.<wbr> Otherwise,<wbr> this describes the real size
+ of the compressed JPEG image placed in the output stream.<wbr>
+ More specifically,<wbr> if android.<wbr>jpeg.<wbr>max<wbr>Size = 1000000,<wbr> and
+ a specific capture has android.<wbr>jpeg.<wbr>size = 500000,<wbr> then
+ the output buffer from the JPEG stream will be 1000000
+ bytes,<wbr> of which the first 500000 make up the real
+ data.<wbr>
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.jpeg.thumbnailQuality">
+ <td class="entry_name">android.<wbr>jpeg.<wbr>thumbnail<wbr>Quality</td>
+ <td class="entry_type">
+ <span class="entry_type_name">byte</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Compression quality of JPEG
+ thumbnail
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ 1-100; larger is higher quality
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.jpeg.thumbnailSize">
+ <td class="entry_name">android.<wbr>jpeg.<wbr>thumbnail<wbr>Size</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 2
+ </span>
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Resolution of embedded JPEG
+ thumbnail
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ from android.<wbr>jpeg.<wbr>available<wbr>Thumbnail<wbr>Sizes
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+
+ <!-- end of section -->
+ <tr><td colspan="7" id="section_lens" class="section">lens</td></tr>
+
+
+ <tr><td colspan="7" class="kind">controls</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="controls_android.lens.aperture">
+ <td class="entry_name">android.<wbr>lens.<wbr>aperture</td>
+ <td class="entry_type">
+ <span class="entry_type_name">float</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Size of the lens aperture
+ </td>
+
+ <td class="entry_units">
+ f-number (f/<wbr>NNN)
+ </td>
+
+ <td class="entry_range">
+ android.<wbr>lens.<wbr>info.<wbr>available<wbr>Apertures
+ </td>
+
+ <td class="entry_notes">
+ Will not be supported on most devices.<wbr> Can only
+ pick from supported list
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.lens.filterDensity">
+ <td class="entry_name">android.<wbr>lens.<wbr>filter<wbr>Density</td>
+ <td class="entry_type">
+ <span class="entry_type_name">float</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ State of lens neutral density
+ filter(s)
+ </td>
+
+ <td class="entry_units">
+ number of stops of filtering
+ </td>
+
+ <td class="entry_range">
+ android.<wbr>lens.<wbr>info.<wbr>available<wbr>Filter<wbr>Densities
+ </td>
+
+ <td class="entry_notes">
+ Will not be supported on most devices.<wbr> Can only
+ pick from supported list
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.lens.focalLength">
+ <td class="entry_name">android.<wbr>lens.<wbr>focal<wbr>Length</td>
+ <td class="entry_type">
+ <span class="entry_type_name">float</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Lens optical zoom setting
+ </td>
+
+ <td class="entry_units">
+ focal length in mm
+ </td>
+
+ <td class="entry_range">
+ > 0
+ </td>
+
+ <td class="entry_notes">
+ Will not be supported on most devices.<wbr>
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.lens.focusDistance">
+ <td class="entry_name">android.<wbr>lens.<wbr>focus<wbr>Distance</td>
+ <td class="entry_type">
+ <span class="entry_type_name">float</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Distance to plane of sharpest focus,<wbr>
+ measured from frontmost surface of the lens
+ </td>
+
+ <td class="entry_units">
+ diopters (1/<wbr>m)
+ </td>
+
+ <td class="entry_range">
+ >= 0
+ </td>
+
+ <td class="entry_notes">
+ 0 = infinity focus.<wbr> Used value should be clamped
+ to (0,<wbr>minimum focus distance)
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.lens.opticalStabilizationMode">
+ <td class="entry_name">android.<wbr>lens.<wbr>optical<wbr>Stabilization<wbr>Mode</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">OFF</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">ON</span>
+ <span class="entry_type_enum_optional">optional</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Whether optical image stabilization is
+ enabled.<wbr>
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ android.<wbr>lens.<wbr>available<wbr>Optical<wbr>Stabilization
+ </td>
+
+ <td class="entry_notes">
+ Will not be supported on most devices.<wbr>
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+ <tr><td colspan="7" class="kind">static</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="static_android.lens.info.availableApertures">
+ <td class="entry_name">android.<wbr>lens.<wbr>info.<wbr>available<wbr>Apertures</td>
+ <td class="entry_type">
+ <span class="entry_type_name">float</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ n
+ </span>
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ List of supported aperture
+ values
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ one entry required,<wbr> > 0
+ </td>
+
+ <td class="entry_notes">
+ If variable aperture not available,<wbr> only setting
+ should be for the fixed aperture
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.lens.info.availableFilterDensities">
+ <td class="entry_name">android.<wbr>lens.<wbr>info.<wbr>available<wbr>Filter<wbr>Densities</td>
+ <td class="entry_type">
+ <span class="entry_type_name">float</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ n
+ </span>
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ List of supported ND filter
+ values
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ one entry required,<wbr> >= 0
+ </td>
+
+ <td class="entry_notes">
+ If not available,<wbr> only setting is 0.<wbr> Otherwise,<wbr>
+ lists the available exposure index values for dimming
+ (2 would mean the filter is set to reduce incoming
+ light by two stops)
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.lens.info.availableFocalLengths">
+ <td class="entry_name">android.<wbr>lens.<wbr>info.<wbr>available<wbr>Focal<wbr>Lengths</td>
+ <td class="entry_type">
+ <span class="entry_type_name">float</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ n
+ </span>
+
+ <div class="entry_type_notes">the list of available focal lengths</div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ If fitted with optical zoom,<wbr> what focal
+ lengths are available.<wbr> If not,<wbr> the static focal
+ length
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ > 0
+ </td>
+
+ <td class="entry_notes">
+ If optical zoom not supported,<wbr> only one value
+ should be reported
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.lens.info.availableOpticalStabilization">
+ <td class="entry_name">android.<wbr>lens.<wbr>info.<wbr>available<wbr>Optical<wbr>Stabilization</td>
+ <td class="entry_type">
+ <span class="entry_type_name">byte</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ n
+ </span>
+
+ <div class="entry_type_notes">list of enums</div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ List of supported optical image
+ stabilization modes
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.lens.info.geometricCorrectionMap">
+ <td class="entry_name">android.<wbr>lens.<wbr>info.<wbr>geometric<wbr>Correction<wbr>Map</td>
+ <td class="entry_type">
+ <span class="entry_type_name">float</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 2 x 3 x n x m
+ </span>
+
+ <div class="entry_type_notes">2D array of destination coordinate pairs for uniform grid points in source image,<wbr> per color channel.<wbr> Size in the range of 2x3x40x30</div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ A low-resolution map for correction of
+ geometric distortions and chromatic aberrations,<wbr> per
+ color channel
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ N,<wbr> M >= 2
+ </td>
+
+ <td class="entry_notes">
+ [DNG wants a function instead].<wbr> What's easiest
+ for implementers? With an array size (M,<wbr> N),<wbr> entry (i,<wbr>
+ j) provides the destination for pixel (i/<wbr>(M-1) * width,<wbr>
+ j/<wbr>(N-1) * height).<wbr> Data is row-major,<wbr> with each array
+ entry being ( (X,<wbr> Y)_<wbr>r,<wbr> (X,<wbr> Y)_<wbr>g,<wbr> (X,<wbr> Y)_<wbr>b ) )
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_DNG">DNG</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.lens.info.geometricCorrectionMapSize">
+ <td class="entry_name">android.<wbr>lens.<wbr>info.<wbr>geometric<wbr>Correction<wbr>Map<wbr>Size</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 2
+ </span>
+
+ <div class="entry_type_notes">width and height of geometric correction map</div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Dimensions of geometric correction
+ map
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ Both values >= 2
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.lens.info.hyperfocalDistance">
+ <td class="entry_name">android.<wbr>lens.<wbr>info.<wbr>hyperfocal<wbr>Distance</td>
+ <td class="entry_type">
+ <span class="entry_type_name">float</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Hyperfocal distance for this lens; set to
+ 0 if fixed focus
+ </td>
+
+ <td class="entry_units">
+ diopters
+ </td>
+
+ <td class="entry_range">
+ >= 0
+ </td>
+
+ <td class="entry_notes">
+ The hyperfocal distance is used for the old
+ API's 'fixed' setting
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.lens.info.minimumFocusDistance">
+ <td class="entry_name">android.<wbr>lens.<wbr>info.<wbr>minimum<wbr>Focus<wbr>Distance</td>
+ <td class="entry_type">
+ <span class="entry_type_name">float</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Shortest distance from frontmost surface
+ of the lens that can be focused correctly
+ </td>
+
+ <td class="entry_units">
+ diopters
+ </td>
+
+ <td class="entry_range">
+ >= 0
+ </td>
+
+ <td class="entry_notes">
+ If the lens is fixed-focus,<wbr> this should be
+ 0
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.lens.info.shadingMap">
+ <td class="entry_name">android.<wbr>lens.<wbr>info.<wbr>shading<wbr>Map</td>
+ <td class="entry_type">
+ <span class="entry_type_name">float</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 3 x n x m
+ </span>
+
+ <div class="entry_type_notes">2D array of float gain factors per channel to correct for lens falloff.<wbr> Should be on the order of 3x40x30</div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ A low-resolution map of lens shading,<wbr> per
+ color channel
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ Each gain factor is >= 1
+ </td>
+
+ <td class="entry_notes">
+ Assume bilinear interpolation of map.<wbr> The least
+ shaded section of the image should have a gain factor
+ of 1; all other sections should have gains above
+ 1.<wbr>
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_DNG">DNG</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.lens.info.shadingMapSize">
+ <td class="entry_name">android.<wbr>lens.<wbr>info.<wbr>shading<wbr>Map<wbr>Size</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 2
+ </span>
+
+ <div class="entry_type_notes">width and height of lens shading map</div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Dimensions of lens shading
+ map
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ Both values >= 1
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+
+
+ <tr class="entry" id="static_android.lens.facing">
+ <td class="entry_name">android.<wbr>lens.<wbr>facing</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">FRONT</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">BACK</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Direction the camera faces relative to
+ device screen
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.lens.opticalAxisAngle">
+ <td class="entry_name">android.<wbr>lens.<wbr>optical<wbr>Axis<wbr>Angle</td>
+ <td class="entry_type">
+ <span class="entry_type_name">float</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 2
+ </span>
+
+ <div class="entry_type_notes">degrees.<wbr> First defines the angle of separation between the perpendicular to the screen and the camera optical axis.<wbr> The second then defines the clockwise rotation of the optical axis from native device up.<wbr></div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Relative angle of camera optical axis to the
+ perpendicular axis from the display
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ [0-90) for first angle,<wbr> [0-360) for second
+ </td>
+
+ <td class="entry_notes">
+ Examples: (0,<wbr>0) means that the camera optical axis
+ is perpendicular to the display surface; (45,<wbr>0) means
+ that the camera points 45 degrees up when device is held
+ upright; (45,<wbr>90) means the camera points 45 degrees to
+ the right when the device is held upright.<wbr> Use FACING
+ field to determine perpendicular outgoing
+ direction
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_ADV">ADV</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.lens.position">
+ <td class="entry_name">android.<wbr>lens.<wbr>position</td>
+ <td class="entry_type">
+ <span class="entry_type_name">float</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 3, location in mm, in the sensor coordinate
+ system
+ </span>
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Coordinates of camera optical axis on
+ device
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+ <tr><td colspan="7" class="kind">dynamic</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="dynamic_android.lens.aperture">
+ <td class="entry_name">android.<wbr>lens.<wbr>aperture</td>
+ <td class="entry_type">
+ <span class="entry_type_name">float</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Size of the lens aperture
+ </td>
+
+ <td class="entry_units">
+ f-number (f/<wbr>NNN)
+ </td>
+
+ <td class="entry_range">
+ android.<wbr>lens.<wbr>info.<wbr>available<wbr>Apertures
+ </td>
+
+ <td class="entry_notes">
+ Will not be supported on most devices.<wbr> Can only
+ pick from supported list
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.lens.filterDensity">
+ <td class="entry_name">android.<wbr>lens.<wbr>filter<wbr>Density</td>
+ <td class="entry_type">
+ <span class="entry_type_name">float</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ State of lens neutral density
+ filter(s)
+ </td>
+
+ <td class="entry_units">
+ number of stops of filtering
+ </td>
+
+ <td class="entry_range">
+ android.<wbr>lens.<wbr>info.<wbr>available<wbr>Filter<wbr>Densities
+ </td>
+
+ <td class="entry_notes">
+ Will not be supported on most devices.<wbr> Can only
+ pick from supported list
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.lens.focalLength">
+ <td class="entry_name">android.<wbr>lens.<wbr>focal<wbr>Length</td>
+ <td class="entry_type">
+ <span class="entry_type_name">float</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Lens optical zoom setting
+ </td>
+
+ <td class="entry_units">
+ focal length in mm
+ </td>
+
+ <td class="entry_range">
+ > 0
+ </td>
+
+ <td class="entry_notes">
+ Will not be supported on most devices.<wbr>
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.lens.focusDistance">
+ <td class="entry_name">android.<wbr>lens.<wbr>focus<wbr>Distance</td>
+ <td class="entry_type">
+ <span class="entry_type_name">float</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Distance to plane of sharpest focus,<wbr>
+ measured from frontmost surface of the lens
+ </td>
+
+ <td class="entry_units">
+ diopters (1/<wbr>m)
+ </td>
+
+ <td class="entry_range">
+ >= 0
+ </td>
+
+ <td class="entry_notes">
+ Should be zero for fixed-focus cameras
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.lens.focusRange">
+ <td class="entry_name">android.<wbr>lens.<wbr>focus<wbr>Range</td>
+ <td class="entry_type">
+ <span class="entry_type_name">float</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ The range of scene distances that are in
+ sharp focus (depth of field)
+ </td>
+
+ <td class="entry_units">
+ pair of focus distances in diopters: (near,<wbr>
+ far)
+ </td>
+
+ <td class="entry_range">
+ >=0
+ </td>
+
+ <td class="entry_notes">
+ If variable focus not supported,<wbr> can still report
+ fixed depth of field range
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.lens.opticalStabilizationMode">
+ <td class="entry_name">android.<wbr>lens.<wbr>optical<wbr>Stabilization<wbr>Mode</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">OFF</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">ON</span>
+ <span class="entry_type_enum_optional">optional</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Whether optical image stabilization is
+ enabled.<wbr>
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ android.<wbr>lens.<wbr>available<wbr>Optical<wbr>Stabilization
+ </td>
+
+ <td class="entry_notes">
+ Will not be supported on most devices.<wbr>
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.lens.state">
+ <td class="entry_name">android.<wbr>lens.<wbr>state</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">STATIONARY</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Current lens status
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+
+ <!-- end of section -->
+ <tr><td colspan="7" id="section_noiseReduction" class="section">noiseReduction</td></tr>
+
+
+ <tr><td colspan="7" class="kind">controls</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="controls_android.noiseReduction.mode">
+ <td class="entry_name">android.<wbr>noise<wbr>Reduction.<wbr>mode</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">OFF</span>
+ <span class="entry_type_enum_notes">No noise reduction is applied</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">FAST</span>
+ <span class="entry_type_enum_notes">Must not slow down frame rate relative to raw
+ bayer output</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">HIGH_QUALITY</span>
+ <span class="entry_type_enum_notes">May slow down frame rate to provide highest
+ quality</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Mode of operation for the noise reduction
+ algorithm
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ android.<wbr>noise<wbr>Reduction.<wbr>available<wbr>Modes
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.noiseReduction.strength">
+ <td class="entry_name">android.<wbr>noise<wbr>Reduction.<wbr>strength</td>
+ <td class="entry_type">
+ <span class="entry_type_name">byte</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Control the amount of noise reduction
+ applied to the images
+ </td>
+
+ <td class="entry_units">
+ 1-10; 10 is max noise reduction
+ </td>
+
+ <td class="entry_range">
+ 1 - 10
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+ <tr><td colspan="7" class="kind">dynamic</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="dynamic_android.noiseReduction.mode">
+ <td class="entry_name">android.<wbr>noise<wbr>Reduction.<wbr>mode</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">OFF</span>
+ <span class="entry_type_enum_notes">No noise reduction is applied</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">FAST</span>
+ <span class="entry_type_enum_notes">Must not slow down frame rate relative to raw
+ bayer output</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">HIGH_QUALITY</span>
+ <span class="entry_type_enum_notes">May slow down frame rate to provide highest
+ quality</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Mode of operation for the noise reduction
+ algorithm
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ android.<wbr>noise<wbr>Reduction.<wbr>available<wbr>Modes
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+
+ <!-- end of section -->
+ <tr><td colspan="7" id="section_quirks" class="section">quirks</td></tr>
+
+
+ <tr><td colspan="7" class="kind">static</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="static_android.quirks.meteringCropRegion">
+ <td class="entry_name">android.<wbr>quirks.<wbr>metering<wbr>Crop<wbr>Region</td>
+ <td class="entry_type">
+ <span class="entry_type_name">byte</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ If set to 1,<wbr> the camera service does not
+ scale 'normalized' coordinates with respect to the crop
+ region.<wbr> This applies to metering input (a{e,<wbr>f,<wbr>wb}Region
+ and output (face rectangles).<wbr>
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ Normalized coordinates refer to those in the
+ (-1000,<wbr>1000) range mentioned in the
+ android.<wbr>hardware.<wbr><wbr>Camera API.<wbr> HAL implementations should
+ instead always use and emit sensor array-relative
+ coordinates for all region data.<wbr> Does not need to be
+ listed in static metadata.<wbr> Support will be removed in
+ future versions of camera service.<wbr>
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.quirks.triggerAfWithAuto">
+ <td class="entry_name">android.<wbr>quirks.<wbr>trigger<wbr>Af<wbr>With<wbr>Auto</td>
+ <td class="entry_type">
+ <span class="entry_type_name">byte</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ If set to 1,<wbr> then the camera service always
+ switches to FOCUS_<wbr>MODE_<wbr>AUTO before issuing a AF
+ trigger.<wbr>
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ HAL implementations should implement AF trigger
+ modes for AUTO,<wbr> MACRO,<wbr> CONTINUOUS_<wbr>FOCUS,<wbr> and
+ CONTINUOUS_<wbr>PICTURE modes instead of using this flag.<wbr> Does
+ not need to be listed in static metadata.<wbr> Support will be
+ removed in future versions of camera service
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.quirks.useZslFormat">
+ <td class="entry_name">android.<wbr>quirks.<wbr>use<wbr>Zsl<wbr>Format</td>
+ <td class="entry_type">
+ <span class="entry_type_name">byte</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ If set to 1,<wbr> the camera service uses
+ CAMERA2_<wbr>PIXEL_<wbr>FORMAT_<wbr>ZSL instead of
+ HAL_<wbr>PIXEL_<wbr>FORMAT_<wbr>IMPLEMENTATION_<wbr>DEFINED for the zero
+ shutter lag stream
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ HAL implementations should use gralloc usage flags
+ to determine that a stream will be used for
+ zero-shutter-lag,<wbr> instead of relying on an explicit
+ format setting.<wbr> Does not need to be listed in static
+ metadata.<wbr> Support will be removed in future versions of
+ camera service.<wbr>
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+
+ <!-- end of section -->
+ <tr><td colspan="7" id="section_request" class="section">request</td></tr>
+
+
+ <tr><td colspan="7" class="kind">controls</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="controls_android.request.frameCount">
+ <td class="entry_name">android.<wbr>request.<wbr>frame<wbr>Count</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ A frame counter set by the framework.<wbr> Must
+ be maintained unchanged in output frame
+ </td>
+
+ <td class="entry_units">
+ incrementing integer
+ </td>
+
+ <td class="entry_range">
+ Any int
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.request.id">
+ <td class="entry_name">android.<wbr>request.<wbr>id</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ An application-specified ID for the current
+ request.<wbr> Must be maintained unchanged in output
+ frame
+ </td>
+
+ <td class="entry_units">
+ arbitrary integer assigned by application
+ </td>
+
+ <td class="entry_range">
+ Any int
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.request.inputStreams">
+ <td class="entry_name">android.<wbr>request.<wbr>input<wbr>Streams</td>
+ <td class="entry_type">
+ <span class="entry_type_name">byte</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ List which camera reprocess stream is used
+ for the source of reprocessing data.<wbr>
+ </td>
+
+ <td class="entry_units">
+ List of camera reprocess stream IDs
+ </td>
+
+ <td class="entry_range">
+ Typically,<wbr> only one entry allowed,<wbr> must be a valid
+ reprocess stream ID.<wbr> If android.<wbr>jpeg.<wbr>needs<wbr>Thumbnail is
+ set,<wbr> then multiple reprocess streams may be included in a
+ single request; they must be different scaled versions of
+ the same image.<wbr>
+ </td>
+
+ <td class="entry_notes">
+ Only meaningful when android.<wbr>request.<wbr>type ==
+ REPROCESS.<wbr> Ignored otherwise
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.request.metadataMode">
+ <td class="entry_name">android.<wbr>request.<wbr>metadata<wbr>Mode</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">NONE</span>
+ <span class="entry_type_enum_notes">No metadata should be produced on output,<wbr> except
+ for application-bound buffer data.<wbr> If no
+ application-bound streams exist,<wbr> no frame should be
+ placed in the output frame queue.<wbr> If such streams
+ exist,<wbr> a frame should be placed on the output queue
+ with null metadata but with the necessary output buffer
+ information.<wbr> Timestamp information should still be
+ included with any output stream buffers</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">FULL</span>
+ <span class="entry_type_enum_notes">All metadata should be produced.<wbr> Statistics will
+ only be produced if they are separately
+ enabled</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ How much metadata to produce on
+ output
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.request.outputStreams">
+ <td class="entry_name">android.<wbr>request.<wbr>output<wbr>Streams</td>
+ <td class="entry_type">
+ <span class="entry_type_name">byte</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Lists which camera output streams image data
+ from this capture must be sent to
+ </td>
+
+ <td class="entry_units">
+ List of camera stream IDs
+ </td>
+
+ <td class="entry_range">
+ List must only include streams that have been
+ created
+ </td>
+
+ <td class="entry_notes">
+ If no output streams are listed,<wbr> then the image
+ data should simply be discarded.<wbr> The image data must
+ still be captured for metadata and statistics production,<wbr>
+ and the lens and flash must operate as requested.<wbr>
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.request.type">
+ <td class="entry_name">android.<wbr>request.<wbr>type</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">CAPTURE</span>
+ <span class="entry_type_enum_notes">Capture a new image from the imaging hardware,<wbr>
+ and process it according to the
+ settings</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">REPROCESS</span>
+ <span class="entry_type_enum_notes">Process previously captured data; the
+ android.<wbr>request.<wbr>input<wbr>Stream parameter determines the
+ source reprocessing stream.<wbr> TODO: Mark dynamic metadata
+ needed for reprocessing with [RP]</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ The type of the request; either CAPTURE or
+ REPROCESS
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+ <tr><td colspan="7" class="kind">static</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="static_android.request.maxNumOutputStreams">
+ <td class="entry_name">android.<wbr>request.<wbr>max<wbr>Num<wbr>Output<wbr>Streams</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 3
+ </span>
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ How many output streams can be allocated at
+ the same time for each type of stream
+ </td>
+
+ <td class="entry_units">
+ The number of raw sensor streams; the number of
+ processed,<wbr> uncompressed streams; and the number of
+ JPEG-compressed streams
+ </td>
+
+ <td class="entry_range">
+ >=1 for Raw and JPEG-compressed stream.<wbr> >= 3
+ for processed,<wbr> uncompressed streams
+ </td>
+
+ <td class="entry_notes">
+ Video snapshot with preview callbacks requires 3
+ processed streams (preview,<wbr> record,<wbr> app callbacks) and
+ one JPEG stream (snapshot)
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.request.maxNumReprocessStreams">
+ <td class="entry_name">android.<wbr>request.<wbr>max<wbr>Num<wbr>Reprocess<wbr>Streams</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 1
+ </span>
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ How many reprocessing streams of any type
+ can be allocated at the same time
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ >= 1
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+ <tr><td colspan="7" class="kind">dynamic</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="dynamic_android.request.frameCount">
+ <td class="entry_name">android.<wbr>request.<wbr>frame<wbr>Count</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Number of frames captured since
+ open()
+ </td>
+
+ <td class="entry_units">
+ count of frames
+ </td>
+
+ <td class="entry_range">
+ > 0
+ </td>
+
+ <td class="entry_notes">
+ Reset on release()
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.request.id">
+ <td class="entry_name">android.<wbr>request.<wbr>id</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ An application-specified ID for the current
+ request.<wbr> Must be maintained unchanged in output
+ frame
+ </td>
+
+ <td class="entry_units">
+ arbitrary integer assigned by application
+ </td>
+
+ <td class="entry_range">
+ Any int
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.request.metadataMode">
+ <td class="entry_name">android.<wbr>request.<wbr>metadata<wbr>Mode</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">NONE</span>
+ <span class="entry_type_enum_notes">No metadata should be produced on output,<wbr> except
+ for application-bound buffer data.<wbr> If no
+ application-bound streams exist,<wbr> no frame should be
+ placed in the output frame queue.<wbr> If such streams
+ exist,<wbr> a frame should be placed on the output queue
+ with null metadata but with the necessary output buffer
+ information.<wbr> Timestamp information should still be
+ included with any output stream buffers</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">FULL</span>
+ <span class="entry_type_enum_notes">All metadata should be produced.<wbr> Statistics will
+ only be produced if they are separately
+ enabled</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ How much metadata to produce on
+ output
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.request.outputStreams">
+ <td class="entry_name">android.<wbr>request.<wbr>output<wbr>Streams</td>
+ <td class="entry_type">
+ <span class="entry_type_name">byte</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Lists which camera output streams image data
+ from this capture must be sent to
+ </td>
+
+ <td class="entry_units">
+ List of camera stream IDs
+ </td>
+
+ <td class="entry_range">
+ List must only include streams that have been
+ created
+ </td>
+
+ <td class="entry_notes">
+ If no output streams are listed,<wbr> then the image
+ data should simply be discarded.<wbr> The image data must
+ still be captured for metadata and statistics production,<wbr>
+ and the lens and flash must operate as requested.<wbr>
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+
+ <!-- end of section -->
+ <tr><td colspan="7" id="section_scaler" class="section">scaler</td></tr>
+
+
+ <tr><td colspan="7" class="kind">controls</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="controls_android.scaler.cropRegion">
+ <td class="entry_name">android.<wbr>scaler.<wbr>crop<wbr>Region</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 3
+ </span>
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Top-left corner and width of the output
+ region to select from the active pixel
+ array
+ </td>
+
+ <td class="entry_units">
+ (x,<wbr>y) of top-left corner,<wbr> width of region in
+ pixels; (0,<wbr>0) is top-left corner of
+ android.<wbr>sensor.<wbr>active<wbr>Pixel<wbr>Array
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ [BC - zoom] Height determined based on width and
+ aspect ratio of output stream.<wbr> Negative values for corner
+ are allowed for raw output if full pixel array is larger
+ than active pixel array.<wbr> Width may be rounded to nearest
+ larger supportable width,<wbr> especially for raw output,<wbr>
+ where only a few fixed scales may be possible
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+ <tr><td colspan="7" class="kind">static</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="static_android.scaler.availableFormats">
+ <td class="entry_name">android.<wbr>scaler.<wbr>available<wbr>Formats</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">int32</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ n
+ </span>
+
+ <div class="entry_type_notes">values from HAL_<wbr>PIXEL_<wbr>FORMAT_<wbr>* in /<wbr>system/<wbr>core/<wbr>include/<wbr>system/<wbr>graphics.<wbr>h</div>
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">RAW_SENSOR</span>
+ <span class="entry_type_enum_value">0x20</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">YV12</span>
+ <span class="entry_type_enum_value">0x32315659</span>
+ <span class="entry_type_enum_notes">YCrCb 4:2:0 Planar</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">YCbCr_420_SP</span>
+ <span class="entry_type_enum_value">0x11</span>
+ <span class="entry_type_enum_notes">NV21</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">JPEG</span>
+ <span class="entry_type_enum_value">0x21</span>
+ <span class="entry_type_enum_notes">BLOB</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ List of app-visible formats
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.scaler.availableJpegMinDurations">
+ <td class="entry_name">android.<wbr>scaler.<wbr>available<wbr>Jpeg<wbr>Min<wbr>Durations</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int64</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ n
+ </span>
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ The minimum frame duration that is supported
+ for each resolution in availableJpegSizes.<wbr> Should
+ correspond to the frame duration when only that JPEG
+ stream is active,<wbr> with all processing set to
+ FAST
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ When multiple streams are configured,<wbr> the minimum
+ frame duration will be >= max(individual stream min
+ durations)
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.scaler.availableJpegSizes">
+ <td class="entry_name">android.<wbr>scaler.<wbr>available<wbr>Jpeg<wbr>Sizes</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ n x 2
+ </span>
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ The resolutions available for output from
+ the JPEG block.<wbr> Listed as width x height
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ Must include: - sensor maximum resolution Should
+ include: - half/<wbr>quarter max resolution
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.scaler.availableMaxDigitalZoom">
+ <td class="entry_name">android.<wbr>scaler.<wbr>available<wbr>Max<wbr>Digital<wbr>Zoom</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ TODO: have a real description here
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.scaler.availableProcessedMinDurations">
+ <td class="entry_name">android.<wbr>scaler.<wbr>available<wbr>Processed<wbr>Min<wbr>Durations</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int64</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ n
+ </span>
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ The minimum frame duration that is supported
+ for each resolution in availableProcessedSizes.<wbr> Should
+ correspond to the frame duration when only that processed
+ stream is active,<wbr> with all processing set to
+ FAST
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ When multiple streams are configured,<wbr> the minimum
+ frame duration will be >= max(individual stream min
+ durations)
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.scaler.availableProcessedSizes">
+ <td class="entry_name">android.<wbr>scaler.<wbr>available<wbr>Processed<wbr>Sizes</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ n x 2
+ </span>
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ The resolutions available for use with
+ processed output streams,<wbr> such as YV12,<wbr> NV12,<wbr> and
+ platform opaque YUV/<wbr>RGB streams to the GPU or video
+ encoders.<wbr> Listed as width,<wbr> height
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ Must include: - sensor maximum resolution -
+ standard QCIF,<wbr> 240p,<wbr> 480p,<wbr> 720p,<wbr> and 1080p
+ resolutions
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.scaler.availableRawMinDurations">
+ <td class="entry_name">android.<wbr>scaler.<wbr>available<wbr>Raw<wbr>Min<wbr>Durations</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int64</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ n
+ </span>
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ The minimum frame duration that is supported
+ for each raw resolution in availableRawSizes.<wbr> Should
+ correspond to the frame duration when only the raw stream
+ is active.<wbr>
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ When multiple streams are configured,<wbr> the minimum
+ frame duration will be >= max(individual stream min
+ durations)
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.scaler.availableRawSizes">
+ <td class="entry_name">android.<wbr>scaler.<wbr>available<wbr>Raw<wbr>Sizes</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ n x 2
+ </span>
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ The resolutions available for use with raw
+ sensor output streams,<wbr> listed as width,<wbr>
+ height
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ Must include: - sensor maximum resolution
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.scaler.maxDigitalZoom">
+ <td class="entry_name">android.<wbr>scaler.<wbr>max<wbr>Digital<wbr>Zoom</td>
+ <td class="entry_type">
+ <span class="entry_type_name">float</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ The maximum ratio between active area width
+ and crop region width,<wbr> or between active area height and
+ crop region height,<wbr> if the crop region height is larger
+ than width
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ >=1
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+ <tr><td colspan="7" class="kind">dynamic</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="dynamic_android.scaler.cropRegion">
+ <td class="entry_name">android.<wbr>scaler.<wbr>crop<wbr>Region</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 3
+ </span>
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Top-left corner and width of the output
+ region to select from the active pixel
+ array
+ </td>
+
+ <td class="entry_units">
+ (x,<wbr>y) of top-left corner,<wbr> width of region in
+ pixels; (0,<wbr>0) is top-left corner of
+ android.<wbr>sensor.<wbr>active<wbr>Pixel<wbr>Array
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ [BC - zoom] Height determined based on width and
+ aspect ratio of output stream.<wbr> Negative values for corner
+ are allowed for raw output if full pixel array is larger
+ than active pixel array.<wbr> Width may be rounded to nearest
+ larger supportable width,<wbr> especially for raw output,<wbr>
+ where only a few fixed scales may be possible
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+
+ <!-- end of section -->
+ <tr><td colspan="7" id="section_sensor" class="section">sensor</td></tr>
+
+
+ <tr><td colspan="7" class="kind">controls</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="controls_android.sensor.exposureTime">
+ <td class="entry_name">android.<wbr>sensor.<wbr>exposure<wbr>Time</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int64</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Duration each pixel is exposed to
+ light
+ </td>
+
+ <td class="entry_units">
+ nanoseconds
+ </td>
+
+ <td class="entry_range">
+ android.<wbr>sensor.<wbr>info.<wbr>exposure<wbr>Time<wbr>Range
+ </td>
+
+ <td class="entry_notes">
+ 1/<wbr>10000 - 30 sec range.<wbr> No bulb mode
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.sensor.frameDuration">
+ <td class="entry_name">android.<wbr>sensor.<wbr>frame<wbr>Duration</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int64</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Duration from start of frame exposure to
+ start of next frame exposure
+ </td>
+
+ <td class="entry_units">
+ nanoseconds
+ </td>
+
+ <td class="entry_range">
+ see android.<wbr>sensor.<wbr>info.<wbr>max<wbr>Frame<wbr>Duration,<wbr>
+ android.<wbr>scaler.<wbr>info.<wbr>available<wbr>Min<wbr>Frame<wbr>Durations
+ </td>
+
+ <td class="entry_notes">
+ Exposure time has priority,<wbr> so duration is set to
+ max(duration,<wbr> exposure time + overhead)
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.sensor.sensitivity">
+ <td class="entry_name">android.<wbr>sensor.<wbr>sensitivity</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Gain applied to image data.<wbr> Must be
+ implemented through analog gain only if set to values
+ below 'maximum analog sensitivity'.<wbr>
+ </td>
+
+ <td class="entry_units">
+ ISO arithmetic units
+ </td>
+
+ <td class="entry_range">
+ android.<wbr>sensor.<wbr>info.<wbr>sensitivity<wbr>Range
+ </td>
+
+ <td class="entry_notes">
+ ISO 12232:2006 REI method
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+ <tr><td colspan="7" class="kind">static</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="static_android.sensor.info.activeArraySize">
+ <td class="entry_name">android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 4
+ </span>
+
+ <div class="entry_type_notes">Four ints defining the active pixel rectangle</div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Area of raw data which corresponds to only
+ active pixels; smaller or equal to
+ pixelArraySize.<wbr>
+ </td>
+
+ <td class="entry_units">
+ xmin,<wbr> ymin,<wbr> width,<wbr> height.<wbr> Top left of full
+ pixel array is (0,<wbr>0)
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_DNG">DNG</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.sensor.info.availableSensitivities">
+ <td class="entry_name">android.<wbr>sensor.<wbr>info.<wbr>available<wbr>Sensitivities</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ n
+ </span>
+
+ <div class="entry_type_notes">List of supported sensitivity values</div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Range of valid sensitivities
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ Must at least include 100,<wbr> 200,<wbr> 400,<wbr> 800,<wbr>
+ 1600
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.sensor.info.colorFilterArrangement">
+ <td class="entry_name">android.<wbr>sensor.<wbr>info.<wbr>color<wbr>Filter<wbr>Arrangement</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">RGGB</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">GRBG</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">GBRG</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">BGGR</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">RGB</span>
+ <span class="entry_type_enum_notes">Sensor is not Bayer; output has 3 16-bit
+ values for each pixel,<wbr> instead of just 1 16-bit value
+ per pixel.<wbr></span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Arrangement of color filters on sensor;
+ represents the colors in the top-left 2x2 section of
+ the sensor,<wbr> in reading order
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_DNG">DNG</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.sensor.info.exposureTimeRange">
+ <td class="entry_name">android.<wbr>sensor.<wbr>info.<wbr>exposure<wbr>Time<wbr>Range</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int64</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 2
+ </span>
+
+ <div class="entry_type_notes">nanoseconds</div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Range of valid exposure
+ times
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ Min <= 100e3 (100 us),<wbr> Max >= 30e9 (30
+ sec)
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.sensor.info.maxFrameDuration">
+ <td class="entry_name">android.<wbr>sensor.<wbr>info.<wbr>max<wbr>Frame<wbr>Duration</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int64</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Maximum frame duration (minimum frame
+ rate)
+ </td>
+
+ <td class="entry_units">
+ nanoseconds
+ </td>
+
+ <td class="entry_range">
+ >= 30e9
+ </td>
+
+ <td class="entry_notes">
+ Minimum duration is a function of resolution,<wbr>
+ processing settings.<wbr> See
+ android.<wbr>scaler.<wbr>info.<wbr>available<wbr>Min<wbr>Frame<wbr>Durations
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.sensor.info.physicalSize">
+ <td class="entry_name">android.<wbr>sensor.<wbr>info.<wbr>physical<wbr>Size</td>
+ <td class="entry_type">
+ <span class="entry_type_name">float</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 2
+ </span>
+
+ <div class="entry_type_notes">width x height in millimeters</div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ The physical dimensions of the full pixel
+ array
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ Needed for FOV calculation for old API
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.sensor.info.pixelArraySize">
+ <td class="entry_name">android.<wbr>sensor.<wbr>info.<wbr>pixel<wbr>Array<wbr>Size</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 2
+ </span>
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Dimensions of full pixel array,<wbr> possibly
+ including black calibration pixels
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ Maximum output resolution for raw format must
+ match this in
+ android.<wbr>scaler.<wbr>info.<wbr>available<wbr>Sizes<wbr>Per<wbr>Format
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_DNG">DNG</a></li>
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.sensor.info.whiteLevel">
+ <td class="entry_name">android.<wbr>sensor.<wbr>info.<wbr>white<wbr>Level</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Maximum raw value output by
+ sensor
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ > 1024 (10-bit output)
+ </td>
+
+ <td class="entry_notes">
+ Defines sensor bit depth (10-14 bits is
+ expected)
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_DNG">DNG</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+
+
+ <tr class="entry" id="static_android.sensor.baseGainFactor">
+ <td class="entry_name">android.<wbr>sensor.<wbr>base<wbr>Gain<wbr>Factor</td>
+ <td class="entry_type">
+ <span class="entry_type_name">rational</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Gain factor from electrons to raw units when
+ ISO=100
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.sensor.blackLevelPattern">
+ <td class="entry_name">android.<wbr>sensor.<wbr>black<wbr>Level<wbr>Pattern</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 4
+ </span>
+
+ <div class="entry_type_notes">2x2 raw count block</div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ A fixed black level offset for each of the
+ Bayer mosaic channels
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ >= 0 each
+ </td>
+
+ <td class="entry_notes">
+ As per DNG BlackLevelRepeatDim /<wbr> BlackLevel
+ tags
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_DNG">DNG</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.sensor.calibrationTransform1">
+ <td class="entry_name">android.<wbr>sensor.<wbr>calibration<wbr>Transform1</td>
+ <td class="entry_type">
+ <span class="entry_type_name">rational</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 9
+ </span>
+
+ <div class="entry_type_notes">3x3 matrix in row-major-order</div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Per-device calibration on top of color space
+ transform 1
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_DNG">DNG</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.sensor.calibrationTransform2">
+ <td class="entry_name">android.<wbr>sensor.<wbr>calibration<wbr>Transform2</td>
+ <td class="entry_type">
+ <span class="entry_type_name">rational</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 9
+ </span>
+
+ <div class="entry_type_notes">3x3 matrix in row-major-order</div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Per-device calibration on top of color space
+ transform 2
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_DNG">DNG</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.sensor.colorTransform1">
+ <td class="entry_name">android.<wbr>sensor.<wbr>color<wbr>Transform1</td>
+ <td class="entry_type">
+ <span class="entry_type_name">rational</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 9
+ </span>
+
+ <div class="entry_type_notes">3x3 matrix in row-major-order</div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Linear mapping from XYZ (D50) color space to
+ reference linear sensor color,<wbr> for first reference
+ illuminant
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ Use as follows XYZ = inv(transform) * clip( (raw -
+ black level(raw) ) /<wbr> ( white level - max black level) ).<wbr>
+ At least in the simple case
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_DNG">DNG</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.sensor.colorTransform2">
+ <td class="entry_name">android.<wbr>sensor.<wbr>color<wbr>Transform2</td>
+ <td class="entry_type">
+ <span class="entry_type_name">rational</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 9
+ </span>
+
+ <div class="entry_type_notes">3x3 matrix in row-major-order</div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Linear mapping from XYZ (D50) color space to
+ reference linear sensor color,<wbr> for second reference
+ illuminant
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_DNG">DNG</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.sensor.forwardMatrix1">
+ <td class="entry_name">android.<wbr>sensor.<wbr>forward<wbr>Matrix1</td>
+ <td class="entry_type">
+ <span class="entry_type_name">rational</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 9
+ </span>
+
+ <div class="entry_type_notes">3x3 matrix in row-major-order</div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Used by DNG for better WB
+ adaptation
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_DNG">DNG</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.sensor.forwardMatrix2">
+ <td class="entry_name">android.<wbr>sensor.<wbr>forward<wbr>Matrix2</td>
+ <td class="entry_type">
+ <span class="entry_type_name">rational</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 9
+ </span>
+
+ <div class="entry_type_notes">3x3 matrix in row-major-order</div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Used by DNG for better WB
+ adaptation
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_DNG">DNG</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.sensor.maxAnalogSensitivity">
+ <td class="entry_name">android.<wbr>sensor.<wbr>max<wbr>Analog<wbr>Sensitivity</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Maximum sensitivity that is implemented
+ purely through analog gain
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ For android.<wbr>sensor.<wbr>sensitivity values less than or
+ equal to this,<wbr> all applied gain must be analog.<wbr> For
+ values above this,<wbr> it can be a mix of analog and
+ digital
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.sensor.noiseModelCoefficients">
+ <td class="entry_name">android.<wbr>sensor.<wbr>noise<wbr>Model<wbr>Coefficients</td>
+ <td class="entry_type">
+ <span class="entry_type_name">float</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 2
+ </span>
+
+ <div class="entry_type_notes">float constants A,<wbr> B for the noise variance model</div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Estimation of sensor noise
+ characteristics
+ </td>
+
+ <td class="entry_units">
+ var(raw pixel value) = electrons * (baseGainFactor
+ * iso/<wbr>100)^2 + A * (baseGainFactor * iso/<wbr>100)^2 +
+ B
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ A represents sensor read noise before analog
+ amplification; B represents noise from A/<wbr>D conversion and
+ other circuits after amplification.<wbr> Both noise sources
+ are assumed to be gaussian,<wbr> independent,<wbr> and not to vary
+ across the sensor
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.sensor.orientation">
+ <td class="entry_name">android.<wbr>sensor.<wbr>orientation</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Clockwise angle through which the output
+ image needs to be rotated to be upright on the device
+ screen in its native orientation.<wbr> Also defines the
+ direction of rolling shutter readout,<wbr> which is from top
+ to bottom in the sensor's coordinate system
+ </td>
+
+ <td class="entry_units">
+ degrees clockwise rotation,<wbr> only multiples of
+ 90
+ </td>
+
+ <td class="entry_range">
+ 0,<wbr>90,<wbr>180,<wbr>270
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.sensor.referenceIlluminant1">
+ <td class="entry_name">android.<wbr>sensor.<wbr>reference<wbr>Illuminant1</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">DAYLIGHT</span>
+ <span class="entry_type_enum_value">1</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">FLUORESCENT</span>
+ <span class="entry_type_enum_value">2</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">TUNGSTEN</span>
+ <span class="entry_type_enum_value">3</span>
+ <span class="entry_type_enum_notes">Incandescent light</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">FLASH</span>
+ <span class="entry_type_enum_value">4</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">FINE_WEATHER</span>
+ <span class="entry_type_enum_value">9</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">CLOUDY_WEATHER</span>
+ <span class="entry_type_enum_value">10</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">SHADE</span>
+ <span class="entry_type_enum_value">11</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">DAYLIGHT_FLUORESCENT</span>
+ <span class="entry_type_enum_value">12</span>
+ <span class="entry_type_enum_notes">D 5700 - 7100K</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">DAY_WHITE_FLUORESCENT</span>
+ <span class="entry_type_enum_value">13</span>
+ <span class="entry_type_enum_notes">N 4600 - 5400K</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">COOL_WHITE_FLUORESCENT</span>
+ <span class="entry_type_enum_value">14</span>
+ <span class="entry_type_enum_notes">W 3900 - 4500K</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">WHITE_FLUORESCENT</span>
+ <span class="entry_type_enum_value">15</span>
+ <span class="entry_type_enum_notes">WW 3200 - 3700K</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">STANDARD_A</span>
+ <span class="entry_type_enum_value">17</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">STANDARD_B</span>
+ <span class="entry_type_enum_value">18</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">STANDARD_C</span>
+ <span class="entry_type_enum_value">19</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">D55</span>
+ <span class="entry_type_enum_value">20</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">D65</span>
+ <span class="entry_type_enum_value">21</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">D75</span>
+ <span class="entry_type_enum_value">22</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">D50</span>
+ <span class="entry_type_enum_value">23</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">ISO_STUDIO_TUNGSTEN</span>
+ <span class="entry_type_enum_value">24</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Light source used to define transform
+ 1
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ [EXIF LightSource tag] Must all these be
+ supported? Need CCT for each!
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_DNG">DNG</a></li>
+ <li><a href="#tag_EXIF">EXIF</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.sensor.referenceIlluminant2">
+ <td class="entry_name">android.<wbr>sensor.<wbr>reference<wbr>Illuminant2</td>
+ <td class="entry_type">
+ <span class="entry_type_name">byte</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Light source used to define transform
+ 2
+ </td>
+
+ <td class="entry_units">
+ Same as illuminant 1
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+ <tr><td colspan="7" class="kind">dynamic</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="dynamic_android.sensor.exposureTime">
+ <td class="entry_name">android.<wbr>sensor.<wbr>exposure<wbr>Time</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int64</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Duration each pixel is exposed to
+ light
+ </td>
+
+ <td class="entry_units">
+ nanoseconds
+ </td>
+
+ <td class="entry_range">
+ android.<wbr>sensor.<wbr>info.<wbr>exposure<wbr>Time<wbr>Range
+ </td>
+
+ <td class="entry_notes">
+ 1/<wbr>10000 - 30 sec range.<wbr> No bulb mode
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.sensor.frameDuration">
+ <td class="entry_name">android.<wbr>sensor.<wbr>frame<wbr>Duration</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int64</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Duration from start of frame exposure to
+ start of next frame exposure
+ </td>
+
+ <td class="entry_units">
+ nanoseconds
+ </td>
+
+ <td class="entry_range">
+ see android.<wbr>sensor.<wbr>info.<wbr>max<wbr>Frame<wbr>Duration,<wbr>
+ android.<wbr>scaler.<wbr>info.<wbr>available<wbr>Min<wbr>Frame<wbr>Durations
+ </td>
+
+ <td class="entry_notes">
+ Exposure time has priority,<wbr> so duration is set to
+ max(duration,<wbr> exposure time + overhead)
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.sensor.sensitivity">
+ <td class="entry_name">android.<wbr>sensor.<wbr>sensitivity</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Gain applied to image data.<wbr> Must be
+ implemented through analog gain only if set to values
+ below 'maximum analog sensitivity'.<wbr>
+ </td>
+
+ <td class="entry_units">
+ ISO arithmetic units
+ </td>
+
+ <td class="entry_range">
+ android.<wbr>sensor.<wbr>info.<wbr>sensitivity<wbr>Range
+ </td>
+
+ <td class="entry_notes">
+ ISO 12232:2006 REI method
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.sensor.timestamp">
+ <td class="entry_name">android.<wbr>sensor.<wbr>timestamp</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int64</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Time at start of exposure of first
+ row
+ </td>
+
+ <td class="entry_units">
+ nanoseconds
+ </td>
+
+ <td class="entry_range">
+ > 0
+ </td>
+
+ <td class="entry_notes">
+ Monotonic,<wbr> should be synced to other timestamps in
+ system
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+
+ <!-- end of section -->
+ <tr><td colspan="7" id="section_shading" class="section">shading</td></tr>
+
+
+ <tr><td colspan="7" class="kind">controls</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="controls_android.shading.mode">
+ <td class="entry_name">android.<wbr>shading.<wbr>mode</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">OFF</span>
+ <span class="entry_type_enum_notes">No shading correction is applied</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">FAST</span>
+ <span class="entry_type_enum_notes">Must not slow down frame rate relative to raw
+ bayer output</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">HIGH_QUALITY</span>
+ <span class="entry_type_enum_notes">Frame rate may be reduced by high
+ quality</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Quality of lens shading correction applied
+ to the image data
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.shading.strength">
+ <td class="entry_name">android.<wbr>shading.<wbr>strength</td>
+ <td class="entry_type">
+ <span class="entry_type_name">byte</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Control the amount of shading correction
+ applied to the images
+ </td>
+
+ <td class="entry_units">
+ unitless: 1-10; 10 is full shading
+ compensation
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_ADV">ADV</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+ <tr><td colspan="7" class="kind">dynamic</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="dynamic_android.shading.mode">
+ <td class="entry_name">android.<wbr>shading.<wbr>mode</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">OFF</span>
+ <span class="entry_type_enum_notes">No shading correction is applied</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">FAST</span>
+ <span class="entry_type_enum_notes">Must not slow down frame rate relative to raw
+ bayer output</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">HIGH_QUALITY</span>
+ <span class="entry_type_enum_notes">Frame rate may be reduced by high
+ quality</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Quality of lens shading correction applied
+ to the image data
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+
+ <!-- end of section -->
+ <tr><td colspan="7" id="section_statistics" class="section">statistics</td></tr>
+
+
+ <tr><td colspan="7" class="kind">controls</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="controls_android.statistics.faceDetectMode">
+ <td class="entry_name">android.<wbr>statistics.<wbr>face<wbr>Detect<wbr>Mode</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">OFF</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">SIMPLE</span>
+ <span class="entry_type_enum_notes">Optional Return rectangle and confidence
+ only</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">FULL</span>
+ <span class="entry_type_enum_notes">Optional Return all face
+ metadata</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ State of the face detector
+ unit
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+
+ android.<wbr>statistics.<wbr>available<wbr>Face<wbr>Detect<wbr>Modes
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.statistics.histogramMode">
+ <td class="entry_name">android.<wbr>statistics.<wbr>histogram<wbr>Mode</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">OFF</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">ON</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Operating mode for histogram
+ generation
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.statistics.sharpnessMapMode">
+ <td class="entry_name">android.<wbr>statistics.<wbr>sharpness<wbr>Map<wbr>Mode</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">OFF</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">ON</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Operating mode for sharpness map
+ generation
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+ <tr><td colspan="7" class="kind">static</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="static_android.statistics.info.availableFaceDetectModes">
+ <td class="entry_name">android.<wbr>statistics.<wbr>info.<wbr>available<wbr>Face<wbr>Detect<wbr>Modes</td>
+ <td class="entry_type">
+ <span class="entry_type_name">byte</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ n
+ </span>
+
+ <div class="entry_type_notes">List of enums</div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Which face detection modes are available,<wbr>
+ if any
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ OFF
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.statistics.info.histogramBucketCount">
+ <td class="entry_name">android.<wbr>statistics.<wbr>info.<wbr>histogram<wbr>Bucket<wbr>Count</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Number of histogram buckets
+ supported
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ >= 64
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.statistics.info.maxFaceCount">
+ <td class="entry_name">android.<wbr>statistics.<wbr>info.<wbr>max<wbr>Face<wbr>Count</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ If face detection is supported,<wbr> how many
+ faces can be detected at once
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ >= 4 if availableFaceDetectionModes lists
+ modes besides OFF,<wbr> otherwise 0
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.statistics.info.maxHistogramCount">
+ <td class="entry_name">android.<wbr>statistics.<wbr>info.<wbr>max<wbr>Histogram<wbr>Count</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Maximum value possible for a histogram
+ bucket
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.statistics.info.maxSharpnessMapValue">
+ <td class="entry_name">android.<wbr>statistics.<wbr>info.<wbr>max<wbr>Sharpness<wbr>Map<wbr>Value</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Maximum value possible for a sharpness map
+ region.<wbr>
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="static_android.statistics.info.sharpnessMapSize">
+ <td class="entry_name">android.<wbr>statistics.<wbr>info.<wbr>sharpness<wbr>Map<wbr>Size</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ 2
+ </span>
+
+ <div class="entry_type_notes">width x height</div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Dimensions of the sharpness
+ map
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ Must be at least 32 x 32
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+
+
+
+ <!-- end of kind -->
+ </tbody>
+ <tr><td colspan="7" class="kind">dynamic</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="dynamic_android.statistics.faceDetectMode">
+ <td class="entry_name">android.<wbr>statistics.<wbr>face<wbr>Detect<wbr>Mode</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">OFF</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">SIMPLE</span>
+ <span class="entry_type_enum_notes">Optional Return rectangle and confidence
+ only</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">FULL</span>
+ <span class="entry_type_enum_notes">Optional Return all face
+ metadata</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ State of the face detector
+ unit
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+
+ android.<wbr>statistics.<wbr>available<wbr>Face<wbr>Detect<wbr>Modes
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.statistics.faceIds">
+ <td class="entry_name">android.<wbr>statistics.<wbr>face<wbr>Ids</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ n
+ </span>
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ List of unique IDs for detected
+ faces
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ Only available if faceDetectMode == FULL
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.statistics.faceLandmarks">
+ <td class="entry_name">android.<wbr>statistics.<wbr>face<wbr>Landmarks</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ n x 6
+ </span>
+
+ <div class="entry_type_notes">(leftEyeX,<wbr> leftEyeY,<wbr> rightEyeX,<wbr> rightEyeY,<wbr> mouthX,<wbr> mouthY)</div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ List of landmarks for detected
+ faces
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ Only available if faceDetectMode == FULL
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.statistics.faceRectangles">
+ <td class="entry_name">android.<wbr>statistics.<wbr>face<wbr>Rectangles</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ n x 4
+ </span>
+
+ <div class="entry_type_notes">(xmin,<wbr> ymin,<wbr> xmax,<wbr> ymax).<wbr> (0,<wbr>0) is top-left of active pixel area</div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ List of the bounding rectangles for detected
+ faces
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ Only available if faceDetectMode != OFF
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.statistics.faceScores">
+ <td class="entry_name">android.<wbr>statistics.<wbr>face<wbr>Scores</td>
+ <td class="entry_type">
+ <span class="entry_type_name">byte</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ n
+ </span>
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ List of the face confidence scores for
+ detected faces
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ 0-100
+ </td>
+
+ <td class="entry_notes">
+ Only available if faceDetectMode != OFF
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_BC">BC</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.statistics.histogram">
+ <td class="entry_name">android.<wbr>statistics.<wbr>histogram</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ n x 3
+ </span>
+
+ <div class="entry_type_notes">count of pixels for each color channel that fall into each histogram bucket,<wbr> scaled to be between 0 and maxHistogramCount</div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ A 3-channel histogram based on the raw
+ sensor data
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ The k'th bucket (0-based) covers the input range
+ (with w = android.<wbr>sensor.<wbr>info.<wbr>white<wbr>Level) of [ k * w/<wbr>N,<wbr>
+ (k + 1) * w /<wbr> N ).<wbr> If only a monochrome sharpness map is
+ supported,<wbr> all channels should have the same data
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.statistics.histogramMode">
+ <td class="entry_name">android.<wbr>statistics.<wbr>histogram<wbr>Mode</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">OFF</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">ON</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Operating mode for histogram
+ generation
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.statistics.sharpnessMap">
+ <td class="entry_name">android.<wbr>statistics.<wbr>sharpness<wbr>Map</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ n x m x 3
+ </span>
+
+ <div class="entry_type_notes">estimated sharpness for each region of the input image.<wbr> Normalized to be between 0 and maxSharpnessMapValue.<wbr> Higher values mean sharper (better focused)</div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ A 3-channel sharpness map,<wbr> based on the raw
+ sensor data
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ If only a monochrome sharpness map is supported,<wbr>
+ all channels should have the same data
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.statistics.sharpnessMapMode">
+ <td class="entry_name">android.<wbr>statistics.<wbr>sharpness<wbr>Map<wbr>Mode</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">OFF</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">ON</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Operating mode for sharpness map
+ generation
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_V1">V1</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+
+ <!-- end of section -->
+ <tr><td colspan="7" id="section_tonemap" class="section">tonemap</td></tr>
+
+
+ <tr><td colspan="7" class="kind">controls</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="controls_android.tonemap.curveBlue">
+ <td class="entry_name">android.<wbr>tonemap.<wbr>curve<wbr>Blue</td>
+ <td class="entry_type">
+ <span class="entry_type_name">float</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Table mapping blue input values to output
+ values
+ </td>
+
+ <td class="entry_units">
+ same as android.<wbr>tonemap.<wbr>curve<wbr>Red
+ </td>
+
+ <td class="entry_range">
+ same as android.<wbr>tonemap.<wbr>curve<wbr>Red
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.tonemap.curveGreen">
+ <td class="entry_name">android.<wbr>tonemap.<wbr>curve<wbr>Green</td>
+ <td class="entry_type">
+ <span class="entry_type_name">float</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Table mapping green input values to output
+ values
+ </td>
+
+ <td class="entry_units">
+ same as android.<wbr>tonemap.<wbr>curve<wbr>Red
+ </td>
+
+ <td class="entry_range">
+ same as android.<wbr>tonemap.<wbr>curve<wbr>Red
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.tonemap.curveRed">
+ <td class="entry_name">android.<wbr>tonemap.<wbr>curve<wbr>Red</td>
+ <td class="entry_type">
+ <span class="entry_type_name">float</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ n x 2
+ </span>
+
+ <div class="entry_type_notes">A 1D array of pairs of floats.<wbr> mapping a 0-1 input range to a 0-1 output range.<wbr></div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Table mapping red input values to output
+ values
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ 0-1 on input and output coordinates.<wbr> Max entry
+ count speciied by android.<wbr>tonemap.<wbr>max<wbr>Curve<wbr>Points
+ </td>
+
+ <td class="entry_notes">
+ .<wbr>The input range must be monotonically increasing
+ with N,<wbr> and values between entries should be linearly
+ interpolated.<wbr> For example,<wbr> if the array is: [0.<wbr>0,<wbr> 0.<wbr>0,<wbr>
+ 0.<wbr>3,<wbr> 0.<wbr>5,<wbr> 1.<wbr>0,<wbr> 1.<wbr>0],<wbr> then the input->output mapping
+ for a few sample points would be: 0 -> 0,<wbr> 0.<wbr>15 ->
+ 0.<wbr>25,<wbr> 0.<wbr>3 -> 0.<wbr>5,<wbr> 0.<wbr>5 -> 0.<wbr>64
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_DNG">DNG</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="controls_android.tonemap.mode">
+ <td class="entry_name">android.<wbr>tonemap.<wbr>mode</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">CONTRAST_CURVE</span>
+ <span class="entry_type_enum_notes">Use the tone mapping curve specified in
+ android.<wbr>tonemap.<wbr>curve</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">FAST</span>
+ <span class="entry_type_enum_notes">Must not slow down frame rate relative to raw
+ bayer output</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">HIGH_QUALITY</span>
+ <span class="entry_type_enum_notes">Frame rate may be reduced by high
+ quality</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+ <tr><td colspan="7" class="kind">static</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="static_android.tonemap.maxCurvePoints">
+ <td class="entry_name">android.<wbr>tonemap.<wbr>max<wbr>Curve<wbr>Points</td>
+ <td class="entry_type">
+ <span class="entry_type_name">int32</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Maximum number of supported points in the
+ tonemap curve
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ >= 128
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+ <tr><td colspan="7" class="kind">dynamic</td></tr>
+
+ <thead>
+ <tr>
+ <th class="th_name">Property Name</th>
+ <th class="th_type">Type</th>
+ <th class="th_description">Description</th>
+ <th class="th_units">Units</th>
+ <th class="th_range">Range</th>
+ <th class="th_notes">Notes</th>
+ <th class="th_tags">Tags</th>
+ </tr>
+ </thead>
+
+ <tbody>
+
+
+
+
+
+
+
+
+
+
+ <tr class="entry" id="dynamic_android.tonemap.curveBlue">
+ <td class="entry_name">android.<wbr>tonemap.<wbr>curve<wbr>Blue</td>
+ <td class="entry_type">
+ <span class="entry_type_name">float</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Table mapping blue input values to output
+ values
+ </td>
+
+ <td class="entry_units">
+ same as android.<wbr>tonemap.<wbr>curve<wbr>Red
+ </td>
+
+ <td class="entry_range">
+ same as android.<wbr>tonemap.<wbr>curve<wbr>Red
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.tonemap.curveGreen">
+ <td class="entry_name">android.<wbr>tonemap.<wbr>curve<wbr>Green</td>
+ <td class="entry_type">
+ <span class="entry_type_name">float</span>
+
+
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Table mapping green input values to output
+ values
+ </td>
+
+ <td class="entry_units">
+ same as android.<wbr>tonemap.<wbr>curve<wbr>Red
+ </td>
+
+ <td class="entry_range">
+ same as android.<wbr>tonemap.<wbr>curve<wbr>Red
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.tonemap.curveRed">
+ <td class="entry_name">android.<wbr>tonemap.<wbr>curve<wbr>Red</td>
+ <td class="entry_type">
+ <span class="entry_type_name">float</span>
+ <span class="entry_type_container">x</span>
+
+ <span class="entry_type_array">
+ n x 2
+ </span>
+
+ <div class="entry_type_notes">A 1D array of pairs of floats.<wbr> mapping a 0-1 input range to a 0-1 output range.<wbr></div>
+
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ Table mapping red input values to output
+ values
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ 0-1 on input and output coordinates.<wbr> Max entry
+ count speciied by android.<wbr>tonemap.<wbr>max<wbr>Curve<wbr>Points
+ </td>
+
+ <td class="entry_notes">
+ .<wbr>The input range must be monotonically increasing
+ with N,<wbr> and values between entries should be linearly
+ interpolated.<wbr> For example,<wbr> if the array is: [0.<wbr>0,<wbr> 0.<wbr>0,<wbr>
+ 0.<wbr>3,<wbr> 0.<wbr>5,<wbr> 1.<wbr>0,<wbr> 1.<wbr>0],<wbr> then the input->output mapping
+ for a few sample points would be: 0 -> 0,<wbr> 0.<wbr>15 ->
+ 0.<wbr>25,<wbr> 0.<wbr>3 -> 0.<wbr>5,<wbr> 0.<wbr>5 -> 0.<wbr>64
+ </td>
+
+ <td class="entry_tags">
+ <ul class="entry_tags">
+ <li><a href="#tag_DNG">DNG</a></li>
+ </ul>
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+ <tr class="entry" id="dynamic_android.tonemap.mode">
+ <td class="entry_name">android.<wbr>tonemap.<wbr>mode</td>
+ <td class="entry_type">
+ <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+ <ul class="entry_type_enum">
+ <li>
+ <span class="entry_type_enum_name">CONTRAST_CURVE</span>
+ <span class="entry_type_enum_notes">Use the tone mapping curve specified in
+ android.<wbr>tonemap.<wbr>curve</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">FAST</span>
+ <span class="entry_type_enum_notes">Must not slow down frame rate relative to raw
+ bayer output</span>
+ </li>
+ <li>
+ <span class="entry_type_enum_name">HIGH_QUALITY</span>
+ <span class="entry_type_enum_notes">Frame rate may be reduced by high
+ quality</span>
+ </li>
+ </ul>
+
+ </td> <!-- entry_type -->
+
+ <td class="entry_description">
+ </td>
+
+ <td class="entry_units">
+ </td>
+
+ <td class="entry_range">
+ </td>
+
+ <td class="entry_notes">
+ </td>
+
+ <td class="entry_tags">
+ </td>
+
+ </tr> <!-- end of entry -->
+
+
+
+ <!-- end of kind -->
+ </tbody>
+
+ <!-- end of section -->
+<!-- </namespace> -->
+ </table>
+
+ <div class="tags" id="tag_index">
+ <h2>Tags</h2>
+ <ul>
+ <li id="tag_AWB">AWB -
+ Needed for auto white balance
+
+ <ul class="tags_entries">
+ <li><a href="#controls_android.control.awbMode">android.control.awbMode</a> (controls)</li>
+ </ul>
+ </li> <!-- tag_AWB -->
+ <li id="tag_BC">BC -
+ Needed for backwards compatibility with old Java API
+
+ <ul class="tags_entries">
+ <li><a href="#controls_android.control.aeExposureCompensation">android.control.aeExposureCompensation</a> (controls)</li>
+ <li><a href="#controls_android.control.aeLock">android.control.aeLock</a> (controls)</li>
+ <li><a href="#controls_android.control.aeMode">android.control.aeMode</a> (controls)</li>
+ <li><a href="#controls_android.control.aeRegions">android.control.aeRegions</a> (controls)</li>
+ <li><a href="#controls_android.control.aeTargetFpsRange">android.control.aeTargetFpsRange</a> (controls)</li>
+ <li><a href="#controls_android.control.afMode">android.control.afMode</a> (controls)</li>
+ <li><a href="#controls_android.control.afRegions">android.control.afRegions</a> (controls)</li>
+ <li><a href="#controls_android.control.awbLock">android.control.awbLock</a> (controls)</li>
+ <li><a href="#controls_android.control.awbMode">android.control.awbMode</a> (controls)</li>
+ <li><a href="#controls_android.control.awbRegions">android.control.awbRegions</a> (controls)</li>
+ <li><a href="#controls_android.control.captureIntent">android.control.captureIntent</a> (controls)</li>
+ <li><a href="#controls_android.control.effectMode">android.control.effectMode</a> (controls)</li>
+ <li><a href="#controls_android.control.mode">android.control.mode</a> (controls)</li>
+ <li><a href="#controls_android.control.sceneMode">android.control.sceneMode</a> (controls)</li>
+ <li><a href="#controls_android.control.videoStabilizationMode">android.control.videoStabilizationMode</a> (controls)</li>
+ <li><a href="#static_android.control.aeCompensationRange">android.control.aeCompensationRange</a> (static)</li>
+ <li><a href="#static_android.control.aeCompensationStep">android.control.aeCompensationStep</a> (static)</li>
+ <li><a href="#static_android.control.afAvailableModes">android.control.afAvailableModes</a> (static)</li>
+ <li><a href="#static_android.control.availableEffects">android.control.availableEffects</a> (static)</li>
+ <li><a href="#static_android.control.availableSceneModes">android.control.availableSceneModes</a> (static)</li>
+ <li><a href="#static_android.control.availableVideoStabilizationModes">android.control.availableVideoStabilizationModes</a> (static)</li>
+ <li><a href="#static_android.control.awbAvailableModes">android.control.awbAvailableModes</a> (static)</li>
+ <li><a href="#static_android.control.maxRegions">android.control.maxRegions</a> (static)</li>
+ <li><a href="#static_android.control.sceneModeOverrides">android.control.sceneModeOverrides</a> (static)</li>
+ <li><a href="#controls_android.flash.mode">android.flash.mode</a> (controls)</li>
+ <li><a href="#static_android.flash.info.available">android.flash.info.available</a> (static)</li>
+ <li><a href="#controls_android.jpeg.gpsCoordinates">android.jpeg.gpsCoordinates</a> (controls)</li>
+ <li><a href="#controls_android.jpeg.gpsProcessingMethod">android.jpeg.gpsProcessingMethod</a> (controls)</li>
+ <li><a href="#controls_android.jpeg.gpsTimestamp">android.jpeg.gpsTimestamp</a> (controls)</li>
+ <li><a href="#controls_android.jpeg.orientation">android.jpeg.orientation</a> (controls)</li>
+ <li><a href="#controls_android.jpeg.quality">android.jpeg.quality</a> (controls)</li>
+ <li><a href="#controls_android.jpeg.thumbnailQuality">android.jpeg.thumbnailQuality</a> (controls)</li>
+ <li><a href="#controls_android.jpeg.thumbnailSize">android.jpeg.thumbnailSize</a> (controls)</li>
+ <li><a href="#static_android.jpeg.availableThumbnailSizes">android.jpeg.availableThumbnailSizes</a> (static)</li>
+ <li><a href="#controls_android.lens.focusDistance">android.lens.focusDistance</a> (controls)</li>
+ <li><a href="#static_android.lens.info.availableFocalLengths">android.lens.info.availableFocalLengths</a> (static)</li>
+ <li><a href="#static_android.lens.info.hyperfocalDistance">android.lens.info.hyperfocalDistance</a> (static)</li>
+ <li><a href="#dynamic_android.lens.focusRange">android.lens.focusRange</a> (dynamic)</li>
+ <li><a href="#static_android.request.maxNumOutputStreams">android.request.maxNumOutputStreams</a> (static)</li>
+ <li><a href="#controls_android.scaler.cropRegion">android.scaler.cropRegion</a> (controls)</li>
+ <li><a href="#static_android.scaler.availableFormats">android.scaler.availableFormats</a> (static)</li>
+ <li><a href="#static_android.scaler.availableJpegMinDurations">android.scaler.availableJpegMinDurations</a> (static)</li>
+ <li><a href="#static_android.scaler.availableJpegSizes">android.scaler.availableJpegSizes</a> (static)</li>
+ <li><a href="#static_android.scaler.availableProcessedMinDurations">android.scaler.availableProcessedMinDurations</a> (static)</li>
+ <li><a href="#static_android.scaler.availableProcessedSizes">android.scaler.availableProcessedSizes</a> (static)</li>
+ <li><a href="#static_android.scaler.availableRawMinDurations">android.scaler.availableRawMinDurations</a> (static)</li>
+ <li><a href="#static_android.scaler.maxDigitalZoom">android.scaler.maxDigitalZoom</a> (static)</li>
+ <li><a href="#controls_android.sensor.frameDuration">android.sensor.frameDuration</a> (controls)</li>
+ <li><a href="#static_android.sensor.info.availableSensitivities">android.sensor.info.availableSensitivities</a> (static)</li>
+ <li><a href="#static_android.sensor.info.maxFrameDuration">android.sensor.info.maxFrameDuration</a> (static)</li>
+ <li><a href="#static_android.sensor.info.physicalSize">android.sensor.info.physicalSize</a> (static)</li>
+ <li><a href="#static_android.sensor.info.pixelArraySize">android.sensor.info.pixelArraySize</a> (static)</li>
+ <li><a href="#static_android.sensor.orientation">android.sensor.orientation</a> (static)</li>
+ <li><a href="#dynamic_android.sensor.timestamp">android.sensor.timestamp</a> (dynamic)</li>
+ <li><a href="#controls_android.statistics.faceDetectMode">android.statistics.faceDetectMode</a> (controls)</li>
+ <li><a href="#dynamic_android.statistics.faceIds">android.statistics.faceIds</a> (dynamic)</li>
+ <li><a href="#dynamic_android.statistics.faceLandmarks">android.statistics.faceLandmarks</a> (dynamic)</li>
+ <li><a href="#dynamic_android.statistics.faceRectangles">android.statistics.faceRectangles</a> (dynamic)</li>
+ <li><a href="#dynamic_android.statistics.faceScores">android.statistics.faceScores</a> (dynamic)</li>
+ <li><a href="#dynamic_android.lens.focalLength">android.lens.focalLength</a> (dynamic)</li>
+ <li><a href="#dynamic_android.lens.focusDistance">android.lens.focusDistance</a> (dynamic)</li>
+ </ul>
+ </li> <!-- tag_BC -->
+ <li id="tag_V1">V1 -
+ New features for first camera 2 release (API1)
+
+ <ul class="tags_entries">
+ <li><a href="#controls_android.demosaic.mode">android.demosaic.mode</a> (controls)</li>
+ <li><a href="#controls_android.flash.firingPower">android.flash.firingPower</a> (controls)</li>
+ <li><a href="#controls_android.flash.firingTime">android.flash.firingTime</a> (controls)</li>
+ <li><a href="#static_android.flash.info.chargeDuration">android.flash.info.chargeDuration</a> (static)</li>
+ <li><a href="#controls_android.hotPixel.mode">android.hotPixel.mode</a> (controls)</li>
+ <li><a href="#controls_android.lens.aperture">android.lens.aperture</a> (controls)</li>
+ <li><a href="#controls_android.lens.filterDensity">android.lens.filterDensity</a> (controls)</li>
+ <li><a href="#controls_android.lens.focalLength">android.lens.focalLength</a> (controls)</li>
+ <li><a href="#controls_android.lens.focusDistance">android.lens.focusDistance</a> (controls)</li>
+ <li><a href="#controls_android.lens.opticalStabilizationMode">android.lens.opticalStabilizationMode</a> (controls)</li>
+ <li><a href="#static_android.lens.info.availableApertures">android.lens.info.availableApertures</a> (static)</li>
+ <li><a href="#static_android.lens.info.availableFilterDensities">android.lens.info.availableFilterDensities</a> (static)</li>
+ <li><a href="#static_android.lens.info.availableFocalLengths">android.lens.info.availableFocalLengths</a> (static)</li>
+ <li><a href="#static_android.lens.info.availableOpticalStabilization">android.lens.info.availableOpticalStabilization</a> (static)</li>
+ <li><a href="#static_android.lens.info.geometricCorrectionMapSize">android.lens.info.geometricCorrectionMapSize</a> (static)</li>
+ <li><a href="#static_android.lens.info.minimumFocusDistance">android.lens.info.minimumFocusDistance</a> (static)</li>
+ <li><a href="#static_android.lens.info.shadingMapSize">android.lens.info.shadingMapSize</a> (static)</li>
+ <li><a href="#static_android.lens.position">android.lens.position</a> (static)</li>
+ <li><a href="#dynamic_android.lens.state">android.lens.state</a> (dynamic)</li>
+ <li><a href="#controls_android.noiseReduction.mode">android.noiseReduction.mode</a> (controls)</li>
+ <li><a href="#controls_android.request.id">android.request.id</a> (controls)</li>
+ <li><a href="#controls_android.sensor.exposureTime">android.sensor.exposureTime</a> (controls)</li>
+ <li><a href="#controls_android.sensor.frameDuration">android.sensor.frameDuration</a> (controls)</li>
+ <li><a href="#controls_android.sensor.sensitivity">android.sensor.sensitivity</a> (controls)</li>
+ <li><a href="#static_android.sensor.info.availableSensitivities">android.sensor.info.availableSensitivities</a> (static)</li>
+ <li><a href="#static_android.sensor.info.exposureTimeRange">android.sensor.info.exposureTimeRange</a> (static)</li>
+ <li><a href="#static_android.sensor.info.maxFrameDuration">android.sensor.info.maxFrameDuration</a> (static)</li>
+ <li><a href="#static_android.sensor.info.physicalSize">android.sensor.info.physicalSize</a> (static)</li>
+ <li><a href="#static_android.sensor.baseGainFactor">android.sensor.baseGainFactor</a> (static)</li>
+ <li><a href="#static_android.sensor.maxAnalogSensitivity">android.sensor.maxAnalogSensitivity</a> (static)</li>
+ <li><a href="#static_android.sensor.noiseModelCoefficients">android.sensor.noiseModelCoefficients</a> (static)</li>
+ <li><a href="#controls_android.statistics.histogramMode">android.statistics.histogramMode</a> (controls)</li>
+ <li><a href="#controls_android.statistics.sharpnessMapMode">android.statistics.sharpnessMapMode</a> (controls)</li>
+ <li><a href="#dynamic_android.statistics.histogram">android.statistics.histogram</a> (dynamic)</li>
+ <li><a href="#dynamic_android.statistics.sharpnessMap">android.statistics.sharpnessMap</a> (dynamic)</li>
+ <li><a href="#dynamic_android.hotPixel.mode">android.hotPixel.mode</a> (dynamic)</li>
+ <li><a href="#dynamic_android.lens.aperture">android.lens.aperture</a> (dynamic)</li>
+ <li><a href="#dynamic_android.lens.filterDensity">android.lens.filterDensity</a> (dynamic)</li>
+ <li><a href="#dynamic_android.lens.opticalStabilizationMode">android.lens.opticalStabilizationMode</a> (dynamic)</li>
+ </ul>
+ </li> <!-- tag_V1 -->
+ <li id="tag_ADV">ADV - None
+ <ul class="tags_entries">
+ <li><a href="#static_android.flash.colorTemperature">android.flash.colorTemperature</a> (static)</li>
+ <li><a href="#static_android.flash.maxEnergy">android.flash.maxEnergy</a> (static)</li>
+ <li><a href="#controls_android.geometric.strength">android.geometric.strength</a> (controls)</li>
+ <li><a href="#static_android.hotPixel.info.map">android.hotPixel.info.map</a> (static)</li>
+ <li><a href="#static_android.lens.opticalAxisAngle">android.lens.opticalAxisAngle</a> (static)</li>
+ <li><a href="#controls_android.shading.strength">android.shading.strength</a> (controls)</li>
+ </ul>
+ </li> <!-- tag_ADV -->
+ <li id="tag_DNG">DNG -
+ Needed for DNG file support
+
+ <ul class="tags_entries">
+ <li><a href="#static_android.lens.info.geometricCorrectionMap">android.lens.info.geometricCorrectionMap</a> (static)</li>
+ <li><a href="#static_android.lens.info.shadingMap">android.lens.info.shadingMap</a> (static)</li>
+ <li><a href="#static_android.sensor.info.activeArraySize">android.sensor.info.activeArraySize</a> (static)</li>
+ <li><a href="#static_android.sensor.info.colorFilterArrangement">android.sensor.info.colorFilterArrangement</a> (static)</li>
+ <li><a href="#static_android.sensor.info.pixelArraySize">android.sensor.info.pixelArraySize</a> (static)</li>
+ <li><a href="#static_android.sensor.info.whiteLevel">android.sensor.info.whiteLevel</a> (static)</li>
+ <li><a href="#static_android.sensor.blackLevelPattern">android.sensor.blackLevelPattern</a> (static)</li>
+ <li><a href="#static_android.sensor.calibrationTransform1">android.sensor.calibrationTransform1</a> (static)</li>
+ <li><a href="#static_android.sensor.calibrationTransform2">android.sensor.calibrationTransform2</a> (static)</li>
+ <li><a href="#static_android.sensor.colorTransform1">android.sensor.colorTransform1</a> (static)</li>
+ <li><a href="#static_android.sensor.colorTransform2">android.sensor.colorTransform2</a> (static)</li>
+ <li><a href="#static_android.sensor.forwardMatrix1">android.sensor.forwardMatrix1</a> (static)</li>
+ <li><a href="#static_android.sensor.forwardMatrix2">android.sensor.forwardMatrix2</a> (static)</li>
+ <li><a href="#static_android.sensor.referenceIlluminant1">android.sensor.referenceIlluminant1</a> (static)</li>
+ <li><a href="#controls_android.tonemap.curveRed">android.tonemap.curveRed</a> (controls)</li>
+ </ul>
+ </li> <!-- tag_DNG -->
+ <li id="tag_EXIF">EXIF - None
+ <ul class="tags_entries">
+ <li><a href="#static_android.sensor.referenceIlluminant1">android.sensor.referenceIlluminant1</a> (static)</li>
+ </ul>
+ </li> <!-- tag_EXIF -->
+ </ul>
+ </div>
+
+ [ <a href="#">top</a> ]
+
+</body>
+</html>
diff --git a/camera/docs/html.mako b/camera/docs/html.mako
index a3a9042..0baf181 100644
--- a/camera/docs/html.mako
+++ b/camera/docs/html.mako
@@ -16,6 +16,7 @@
limitations under the License.
-->
<head>
+ <!-- automatically generated from html.mako. do NOT edit directly -->
<meta charset="utf-8" />
<title>Android Camera HAL2.0 Properties</title>
<style type="text/css">
@@ -41,6 +42,7 @@
/* Entry type flair */
.entry_type_name { color: darkgreen; font-weight: bold; }
+ .entry_type_name_enum:after { color: darkgreen; font-weight: bold; content:" (enum)" }
.entry_type_enum_name { font-family: monospace; font-weight: bolder; }
.entry_type_enum_notes:before { content:" - " }
.entry_type_enum_value:before { content:" = " }
@@ -56,14 +58,35 @@
/* TODO for each x.y.z try to link it to the entry */
</style>
+
+ <style>
+
+ {
+ /* broken...
+ supposedly there is a bug in chrome that it lays out tables before
+ it knows its being printed, so the page-break-* styles are ignored
+ */
+ tr { page-break-after: always; page-break-inside: avoid; }
+ }
+
+ </style>
</head>
<%!
# insert word break hints for the browser
- # e.g. X/Y/Z -> X/<wbr>Y/<wbr>/Z. also for X.Y.Z, X_Y_Z.
def wbr(text):
- replace_chars=['.', '/', '_', ',']
new_txt = text
+
+ # for johnyOrange.appleCider.redGuardian also insert wbr before the caps
+ # => johny<wbr>Orange.apple<wbr>Cider.red<wbr>Guardian
+ for words in text.split(" "):
+ if len(words.split(".")) >= 3: # match only x.y.z
+ addwbr = lambda x: i.isupper() and ("<wbr>" + i) or i
+ new_word = "".join([addwbr(i) for i in words])
+ new_txt = new_txt.replace(words, new_word)
+
+ # e.g. X/Y/Z -> X/<wbr>Y/<wbr>/Z. also for X.Y.Z, X_Y_Z.
+ replace_chars=['.', '/', '_', ',']
for i in replace_chars:
new_txt = new_txt.replace(i, i + "<wbr>")
@@ -114,7 +137,7 @@
<tr class="description"><td>${section.description}</td></tr>
% endif
- % for kind in section.kinds: # dynamic,static,controls
+ % for kind in section.merged_kinds: # dynamic,static,controls
<tr><td colspan="7" class="kind">${kind.name}</td></tr>
<thead>
@@ -162,7 +185,11 @@
<tr class="entry" id="${prop.kind}_${prop.name}">
<td class="entry_name">${prop.name | wbr}</td>
<td class="entry_type">
- <span class="entry_type_name">${prop.type}</span>
+ % if prop.enum:
+ <span class="entry_type_name entry_type_name_enum">${prop.type}</span>
+ % else:
+ <span class="entry_type_name">${prop.type}</span>
+ % endif
% if prop.container is not None:
<span class="entry_type_container">x</span>
% endif
@@ -183,7 +210,7 @@
<div class="entry_type_notes">${prop.type_notes | wbr}</div>
% endif
- % if prop.type == 'enum':
+ % if prop.enum:
<ul class="entry_type_enum">
% for value in prop.enum.values:
<li>
@@ -229,7 +256,7 @@
</td>
<td class="entry_tags">
- % if list(prop.tags):
+ % if next(prop.tags, None):
<ul class="entry_tags">
% for tag in prop.tags:
<li><a href="#tag_${tag.id}">${tag.id}</a></li>
diff --git a/camera/docs/metadata-check-dependencies b/camera/docs/metadata-check-dependencies
new file mode 100755
index 0000000..d4f768a
--- /dev/null
+++ b/camera/docs/metadata-check-dependencies
@@ -0,0 +1,114 @@
+#!/bin/bash
+
+#
+# Copyright (C) 2012 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+packager=""
+retcode=0
+if [[ "$OSTYPE" == "darwin"* ]]
+then
+ packager="macports"
+
+ if ! which port >& /dev/null
+ then
+ echo "Missing port binary, please install from http://www.macports.org/" >& 2
+ fi
+elif [[ "$OSTYPE" == "linux-gnu" ]] && which apt-get >& /dev/null
+then
+ packager="apt-get"
+fi
+
+function packager_install
+{
+ if [[ $packager == "macports" ]]
+ then
+ echo "sudo port install $1"
+ elif [[ $packager == "apt-get" ]]
+ then
+ echo "sudo apt-get install $1"
+ else
+ echo "<your package manager> install $1"
+ fi
+}
+
+function binary_check()
+{
+ local bin=$1
+ local macports=$2
+ local aptget=$3
+
+ local pkg=""
+
+ if type -f "$bin" >& /dev/null
+ then
+ return 0
+ fi
+
+ if [[ $packager == "macports" ]]
+ then
+ pkg="$macports"
+ elif [[ $packager == "apt-get" ]]
+ then
+ pkg="$aptget"
+ fi
+
+ if [[ -n $pkg ]]
+ then
+ echo "Missing $bin binary please install with '$(packager_install $pkg)'"
+ fi
+
+ retcode=1
+ return 1
+}
+
+function python_check()
+{
+ local mod=$1
+ local macports=$2
+ local aptget=$3
+
+ local pkg=""
+
+ if python -c "import $mod" >& /dev/null
+ then
+ return 0
+ fi
+
+ if [[ $packager == "macports" ]]
+ then
+ pkg="$macports"
+ elif [[ $packager == "apt-get" ]]
+ then
+ pkg="$aptget"
+ fi
+
+ if [[ -n $pkg ]]
+ then
+ echo "Missing python module $mod, please install with '$(packager_install $pkg)'"
+ fi
+
+ retcode=1
+ return 1
+}
+
+binary_check xmllint libxml2 libxml2-utils
+binary_check tidy tidy tidy
+binary_check python python27 python2.7
+python_check bs4 py27-beautifulsoup4 python-bs4
+python_check mako py27-mako python-mako
+
+exit $retcode
+
diff --git a/camera/docs/metadata-generate b/camera/docs/metadata-generate
new file mode 100755
index 0000000..7869763
--- /dev/null
+++ b/camera/docs/metadata-generate
@@ -0,0 +1,58 @@
+#!/bin/bash
+
+#
+# Copyright (C) 2012 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+#
+# Generate all files we have templates for:
+# docs.html
+# ../src/camera_metadata_tag_info.c
+# ../src/camera_metadata_tags.h
+#
+
+thisdir=$(dirname $(readlink -f $0))
+
+function relpath() {
+ python -c "import os.path; print os.path.relpath('$1', '$PWD')"
+}
+
+function gen_file() {
+ local in=$thisdir/$1
+ local out=$thisdir/$2
+
+ python $thisdir/metadata_parser_xml.py $thisdir/metadata_properties.xml $in $out
+
+ local succ=$?
+
+ if [[ $succ -eq 0 ]]
+ then
+ echo "OK: Generated $(relpath "$out")"
+ else
+ echo "FAIL: Errors while generating $(relpath "$out")" >& 2
+ fi
+
+ return $succ
+}
+
+$thisdir/metadata-check-dependencies || exit 1
+$thisdir/metadata-parser-sanity-check || exit 1
+gen_file html.mako docs.html || exit 1
+gen_file camera_metadata_tag_info.mako ../src/camera_metadata_tag_info.c || exit 1
+gen_file camera_metadata_tags.mako ../include/system/camera_metadata_tags.h || exit 1
+
+echo "Successfully generated all metadata source files"
+
+exit 0
diff --git a/camera/docs/metadata-parser-sanity-check b/camera/docs/metadata-parser-sanity-check
index e47ec0b..520a5f2 100755
--- a/camera/docs/metadata-parser-sanity-check
+++ b/camera/docs/metadata-parser-sanity-check
@@ -21,20 +21,15 @@
# as the original parsed data.
#
-tidy=$(which tidy)
-if [[ $? -ne 0 ]]
-then
- echo "Missing tidy binary, please install with 'sudo apt-get install tidy'" 1>&2
- exit 1
-fi
-
thisdir=$(dirname $(readlink -f $0))
+$thisdir/metadata-check-dependencies || exit 1
+
tmp_out=$(mktemp)
tmp_tidy1=$(mktemp)
tmp_tidy2=$(mktemp)
-$thisdir/metadata_parser_xml.py $thisdir/metadata_properties.xml $thisdir/metadata_template.mako > $tmp_out
+python $thisdir/metadata_parser_xml.py $thisdir/metadata_properties.xml $thisdir/metadata_template.mako $tmp_out || exit 1
tidy -indent -xml -quiet $thisdir/metadata_properties.xml > $tmp_tidy1
tidy -indent -xml -quiet $tmp_out > $tmp_tidy2
diff --git a/camera/docs/metadata-validate b/camera/docs/metadata-validate
index fe0266b..20ad9e6 100755
--- a/camera/docs/metadata-validate
+++ b/camera/docs/metadata-validate
@@ -16,12 +16,8 @@
# limitations under the License.
#
-xmllint=$(which xmllint)
-if [[ $? -ne 0 ]]
-then
- echo "Missing xmllint binary, please install with 'sudo apt-get install libxml2-utils'" 1>&2
- exit 1
-fi
+thisdir=$(dirname $(readlink -f $0))
+$thisdir/metadata-check-dependencies || exit 1
if [[ $# -lt 1 ]]
then
@@ -29,11 +25,9 @@
exit
fi
-thisdir=$(dirname $(readlink -f $0))
-
schema=$thisdir/metadata_properties.xsd
doc=$1
xmllint --noout --schema $schema $out $doc || exit 1
-$thisdir/metadata_validate.py $doc || exit 1
+python $thisdir/metadata_validate.py $doc || exit 1
diff --git a/camera/docs/metadata_helpers.py b/camera/docs/metadata_helpers.py
new file mode 100644
index 0000000..fd09d98
--- /dev/null
+++ b/camera/docs/metadata_helpers.py
@@ -0,0 +1,243 @@
+#
+# Copyright (C) 2012 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""
+A set of helpers for rendering Mako templates with a Metadata model.
+"""
+
+import metadata_model
+from collections import OrderedDict
+
+_context_buf = None
+
+def _is_sec_or_ins(x):
+ return isinstance(x, metadata_model.Section) or \
+ isinstance(x, metadata_model.InnerNamespace)
+
+##
+## Metadata Helpers
+##
+
+def find_all_sections(root):
+ """
+ Find all descendants that are Section or InnerNamespace instances.
+
+ Args:
+ root: a Metadata instance
+
+ Returns:
+ A list of Section/InnerNamespace instances
+
+ Remarks:
+ These are known as "sections" in the generated C code.
+ """
+ return root.find_all(_is_sec_or_ins)
+
+def find_parent_section(entry):
+ """
+ Find the closest ancestor that is either a Section or InnerNamespace.
+
+ Args:
+ entry: an Entry or Clone node
+
+ Returns:
+ An instance of Section or InnerNamespace
+ """
+ return entry.find_parent_first(_is_sec_or_ins)
+
+# find uniquely named entries (w/o recursing through inner namespaces)
+def find_unique_entries(node):
+ """
+ Find all uniquely named entries, without recursing through inner namespaces.
+
+ Args:
+ node: a Section or InnerNamespace instance
+
+ Yields:
+ A sequence of MergedEntry nodes representing an entry
+
+ Remarks:
+ This collapses multiple entries with the same fully qualified name into
+ one entry (e.g. if there are multiple entries in different kinds).
+ """
+ if not isinstance(node, metadata_model.Section) and \
+ not isinstance(node, metadata_model.InnerNamespace):
+ raise TypeError("expected node to be a Section or InnerNamespace")
+
+ d = OrderedDict()
+ # remove the 'kinds' from the path between sec and the closest entries
+ # then search the immediate children of the search path
+ search_path = isinstance(node, metadata_model.Section) and node.kinds \
+ or [node]
+ for i in search_path:
+ for entry in i.entries:
+ d[entry.name] = entry
+
+ for k,v in d.iteritems():
+ yield v.merge()
+
+def path_name(node):
+ """
+ Calculate a period-separated string path from the root to this element,
+ by joining the names of each node and excluding the Metadata/Kind nodes
+ from the path.
+
+ Args:
+ node: a Node instance
+
+ Returns:
+ A string path
+ """
+
+ isa = lambda x,y: isinstance(x, y)
+ fltr = lambda x: not isa(x, metadata_model.Metadata) and \
+ not isa(x, metadata_model.Kind)
+
+ path = node.find_parents(fltr)
+ path = list(path)
+ path.reverse()
+ path.append(node)
+
+ return ".".join((i.name for i in path))
+
+##
+## Filters
+##
+
+# abcDef.xyz -> ABC_DEF_XYZ
+def csym(name):
+ """
+ Convert an entry name string into an uppercase C symbol.
+
+ Returns:
+ A string
+
+ Example:
+ csym('abcDef.xyz') == 'ABC_DEF_XYZ'
+ """
+ newstr = name
+ newstr = "".join([i.isupper() and ("_" + i) or i for i in newstr]).upper()
+ newstr = newstr.replace(".", "_")
+ return newstr
+
+# abcDef.xyz -> abc_def_xyz
+def csyml(name):
+ """
+ Convert an entry name string into a lowercase C symbol.
+
+ Returns:
+ A string
+
+ Example:
+ csyml('abcDef.xyz') == 'abc_def_xyz'
+ """
+ return csym(name).lower()
+
+# pad with spaces to make string len == size. add new line if too big
+def ljust(size, indent=4):
+ """
+ Creates a function that given a string will pad it with spaces to make
+ the string length == size. Adds a new line if the string was too big.
+
+ Args:
+ size: an integer representing how much spacing should be added
+ indent: an integer representing the initial indendation level
+
+ Returns:
+ A function that takes a string and returns a string.
+
+ Example:
+ ljust(8)("hello") == 'hello '
+
+ Remarks:
+ Deprecated. Use pad instead since it works for non-first items in a
+ Mako template.
+ """
+ def inner(what):
+ newstr = what.ljust(size)
+ if len(newstr) > size:
+ return what + "\n" + "".ljust(indent + size)
+ else:
+ return newstr
+ return inner
+
+def _find_new_line():
+
+ if _context_buf is None:
+ raise ValueError("Context buffer was not set")
+
+ buf = _context_buf
+ x = -1 # since the first read is always ''
+ cur_pos = buf.tell()
+ while buf.tell() > 0 and buf.read(1) != '\n':
+ buf.seek(cur_pos - x)
+ x = x + 1
+
+ buf.seek(cur_pos)
+
+ return int(x)
+
+# Pad the string until the buffer reaches the desired column.
+# If string is too long, insert a new line with 'col' spaces instead
+def pad(col):
+ """
+ Create a function that given a string will pad it to the specified column col.
+ If the string overflows the column, put the string on a new line and pad it.
+
+ Args:
+ col: an integer specifying the column number
+
+ Returns:
+ A function that given a string will produce a padded string.
+
+ Example:
+ pad(8)("hello") == 'hello '
+
+ Remarks:
+ This keeps track of the line written by Mako so far, so it will always
+ align to the column number correctly.
+ """
+ def inner(what):
+ wut = int(col)
+ current_col = _find_new_line()
+
+ if len(what) > wut - current_col:
+ return what + "\n".ljust(col)
+ else:
+ return what.ljust(wut - current_col)
+ return inner
+
+# int32 -> TYPE_INT32, byte -> TYPE_BYTE, etc. note that enum -> TYPE_INT32
+def ctype_enum(what):
+ """
+ Generate a camera_metadata_type_t symbol from a type string.
+
+ Args:
+ what: a type string
+
+ Returns:
+ A string representing the camera_metadata_type_t
+
+ Example:
+ ctype_enum('int32') == 'TYPE_INT32'
+ ctype_enum('int64') == 'TYPE_INT64'
+ ctype_enum('float') == 'TYPE_FLOAT'
+
+ Remarks:
+ An enum is coerced to a byte since the rest of the camera_metadata
+ code doesn't support enums directly yet.
+ """
+ return 'TYPE_%s' %(what.upper())
diff --git a/camera/docs/metadata_model.py b/camera/docs/metadata_model.py
index b6215ae..fa85a58 100644
--- a/camera/docs/metadata_model.py
+++ b/camera/docs/metadata_model.py
@@ -34,6 +34,8 @@
"""
import sys
+import itertools
+from collections import OrderedDict
class Node(object):
"""
@@ -152,7 +154,7 @@
@staticmethod
def _dictionary_by_name(values):
- d = {}
+ d = OrderedDict()
for i in values:
d[i.name] = i
@@ -205,6 +207,7 @@
self._entries = []
# kind => { name => entry }
self._entry_map = { 'static': {}, 'dynamic': {}, 'controls': {} }
+ self._entries_ordered = [] # list of ordered Entry/Clone instances
self._clones = []
# Public (Read Only)
@@ -248,7 +251,7 @@
"""
tag_ids = [tg.name for tg in self.tags if tg.name == tag]
if not tag_ids:
- self._tags.append(Tag(tag, self))
+ self._tags.append(Tag(tag, self, description))
def insert_entry(self, entry):
"""
@@ -265,6 +268,7 @@
e = Entry(**entry)
self._entries.append(e)
self._entry_map[e.kind][e.name] = e
+ self._entries_ordered.append(e)
def insert_clone(self, clone):
"""
@@ -285,6 +289,7 @@
c = Clone(entry, **clone)
self._entry_map[c.kind][c.name] = c
self._clones.append(c)
+ self._entries_ordered.append(c)
def prune_clones(self):
"""
@@ -311,6 +316,7 @@
# remove from global list
self._clones.remove(p)
self._entry_map[p.kind].pop(p.name)
+ self._entries_ordered.remove(p)
# After all entries/clones are inserted,
@@ -367,7 +373,7 @@
for ons_name, ons in root.iteritems():
ons._leafs = []
- for p in self._get_properties():
+ for p in self._entries_ordered:
ons_name = p.get_outer_namespace()
ons = root.get(ons_name, OuterNamespace(ons_name, self))
root[ons_name] = ons
@@ -380,7 +386,6 @@
ons.validate_tree()
self._construct_sections(ons)
- ons.sort_children()
if ons not in self._outer_namespaces:
self._outer_namespaces.append(ons)
@@ -414,7 +419,6 @@
%(sec)
self._construct_kinds(sec)
- sec.sort_children()
if sec not in outer_namespace.sections:
outer_namespace._sections.append(sec)
@@ -426,43 +430,35 @@
# 'controls', 'static' 'dynamic'. etc
def _construct_kinds(self, section):
-
- kinds_dict = self._dictionary_by_name(section.kinds)
- for name, kind in kinds_dict.iteritems():
+ for kind in section.kinds:
kind._leafs = []
section.validate_tree()
- for p in section._leafs:
- kind = kinds_dict.get(p.kind, Kind(p.kind, section))
- kinds_dict[p.kind] = kind
- section.validate_tree()
+ group_entry_by_kind = itertools.groupby(section._leafs, lambda x: x.kind)
+ leaf_it = ((k, g) for k, g in group_entry_by_kind)
- if p not in kind._leafs:
- kind._leafs.append(p)
+ # allow multiple kinds with the same name. merge if adjacent
+ # e.g. dynamic,dynamic,static,static,dynamic -> dynamic,static,dynamic
+ # this helps maintain ABI compatibility when adding an entry in a new kind
+ for idx, (kind_name, entry_it) in enumerate(leaf_it):
+ if idx >= len(section._kinds):
+ kind = Kind(kind_name, section)
+ section._kinds.append(kind)
+ section.validate_tree()
- if len(kinds_dict) > 3:
- sec = section
- if sec is not None:
- sec_name = sec.name
- else:
- sec_name = "Unknown"
+ kind = section._kinds[idx]
- print >> sys.stderr, ("ERROR: Kind '%s' has too many children(%d) " + \
- "in section '%s'") %(name, len(kc), sec_name)
+ for p in entry_it:
+ if p not in kind._leafs:
+ kind._leafs.append(p)
-
- for name, kind in kinds_dict.iteritems():
-
+ for kind in section._kinds:
kind.validate_tree()
self._construct_inner_namespaces(kind)
kind.validate_tree()
self._construct_entries(kind)
- kind.sort_children()
kind.validate_tree()
- if kind not in section.kinds:
- section._kinds.append(kind)
-
if not section.validate_tree():
print >> sys.stderr, ("ERROR: Failed to validate tree in " + \
"construct_kinds, with kind = '%s'") %(kind)
@@ -495,7 +491,6 @@
ins.validate_tree()
# construct children entries
self._construct_entries(ins, depth + 1)
- ins.sort_children()
if ins not in parent.namespaces:
parent._namespaces.append(ins)
@@ -603,6 +598,8 @@
parent: An edge to the parent, which is always an OuterNamespace instance.
description: A string description of the section, or None.
kinds: A sequence of Kind children.
+ merged_kinds: A sequence of virtual Kind children,
+ with each Kind's children merged by the kind.name
"""
def __init__(self, name, parent, description=None, kinds=[]):
self._name = name
@@ -634,6 +631,27 @@
def _get_children(self):
return (i for i in self.kinds)
+ @property
+ def merged_kinds(self):
+
+ def aggregate_by_name(acc, el):
+ existing = [i for i in acc if i.name == el.name]
+ if existing:
+ k = existing[0]
+ else:
+ k = Kind(el.name, el.parent)
+ acc.append(k)
+
+ k._namespaces.extend(el._namespaces)
+ k._entries.extend(el._entries)
+
+ return acc
+
+ new_kinds_lst = reduce(aggregate_by_name, self.kinds, [])
+
+ for k in new_kinds_lst:
+ yield k
+
class Kind(Node):
"""
A node corresponding to one of: <static>,<dynamic>,<controls> under a
@@ -719,7 +737,7 @@
for i in self.entries:
yield i
-class EnumValue(object):
+class EnumValue(Node):
"""
A class corresponding to a <value> element within an <enum> within an <entry>.
@@ -728,16 +746,14 @@
id: An optional numeric string, e.g. '0' or '0xFF'
optional: A boolean
notes: A string describing the notes, or None.
+ parent: An edge to the parent, always an Enum instance.
"""
- def __init__(self, name, id=None, optional=False, notes=None):
+ def __init__(self, name, parent, id=None, optional=False, notes=None):
self._name = name # str, e.g. 'ON' or 'OFF'
self._id = id # int, e.g. '0'
self._optional = optional # bool
self._notes = notes # None or str
-
- @property
- def name(self):
- return self._name
+ self._parent = parent
@property
def id(self):
@@ -751,7 +767,10 @@
def notes(self):
return self._notes
-class Enum(object):
+ def _get_children(self):
+ return None
+
+class Enum(Node):
"""
A class corresponding to an <enum> element within an <entry>.
@@ -761,19 +780,19 @@
"""
def __init__(self, parent, values, ids={}, optionals=[], notes={}):
self._values = \
- [ EnumValue(val, ids.get(val), val in optionals, notes.get(val)) \
+ [ EnumValue(val, self, ids.get(val), val in optionals, notes.get(val)) \
for val in values ]
self._parent = parent
-
- @property
- def parent(self):
- return self._parent
+ self._name = None
@property
def values(self):
return (i for i in self._values)
+ def _get_children(self):
+ return (i for i in self._values)
+
class Entry(Node):
"""
A node corresponding to an <entry> element.
@@ -787,7 +806,7 @@
ancestor Kind#name
container: The container attribute from <entry container="array">, or None.
container_sizes: A sequence of size strings or None if container is None.
- enum: An Enum instance if type is 'enum', None otherwise.
+ enum: An Enum instance if the enum attribute is true, None otherwise.
tuple_values: A sequence of strings describing the tuple values,
None if container is not 'tuple'.
description: A string description, or None.
@@ -819,7 +838,8 @@
Args (if container is 'tuple'):
tuple_values: A list of tuple values, e.g. ['width', 'height']
- Args (if type is 'enum'):
+ Args (if the 'enum' attribute is true):
+ enum: A boolean, True if this is an enum, False otherwise
enum_values: A list of value strings, e.g. ['ON', 'OFF']
enum_optionals: A list of optional enum values, e.g. ['OFF']
enum_notes: A dictionary of value->notes strings.
@@ -909,7 +929,8 @@
return self._enum
def _get_children(self):
- return None
+ if self.enum:
+ yield self.enum
def sort_children(self):
return None
@@ -947,7 +968,7 @@
self._type_notes = kwargs.get('type_notes')
- if self._type == 'enum':
+ if kwargs.get('enum', False):
self._enum = Enum(self, enum_values, enum_ids, enum_optionals, enum_notes)
else:
self._enum = None
@@ -1024,6 +1045,17 @@
"""
return self.get_name_as_list()[-1]
+ def get_path_without_name(self):
+ """
+ Returns a string path to the entry, with the name component excluded.
+
+ For example:
+ entry.name is 'android.lens.info.shading'
+ entry.get_path_without_name() == 'android.lens.info'
+ """
+ return ".".join(self.get_name_as_list()[0:-1])
+
+
class Clone(Entry):
"""
A Node corresponding to a <clone> element. It has all the attributes of an
@@ -1054,7 +1086,8 @@
Args (if container is 'tuple'):
tuple_values: A list of tuple values, e.g. ['width', 'height']
- Args (if type is 'enum'):
+ Args (if the 'enum' attribute is true):
+ enum: A boolean, True if this is an enum, False otherwise
enum_values: A list of value strings, e.g. ['ON', 'OFF']
enum_optionals: A list of optional enum values, e.g. ['OFF']
enum_notes: A dictionary of value->notes strings.
@@ -1121,22 +1154,22 @@
props_distinct = ['description', 'units', 'range', 'notes', 'tags', 'kind']
for p in props_distinct:
+ p = '_' + p
if entry.is_clone():
- setattr(self, '_' + p, getattr(entry, p) or getattr(entry.entry, p))
+ setattr(self, p, getattr(entry, p) or getattr(entry.entry, p))
else:
- setattr(self, '_' + p, getattr(entry, p))
+ setattr(self, p, getattr(entry, p))
- props_common = ['parent', 'name', 'name_short', 'container',
+ props_common = ['parent', 'name', 'container',
'container_sizes', 'enum',
'tuple_values',
'type',
'type_notes',
- 'enum'
]
for p in props_common:
+ p = '_' + p
if entry.is_clone():
- setattr(self, '_' + p, getattr(entry.entry, p))
+ setattr(self, p, getattr(entry.entry, p))
else:
- setattr(self, '_' + p, getattr(entry, p))
-
+ setattr(self, p, getattr(entry, p))
diff --git a/camera/docs/metadata_parser_xml.py b/camera/docs/metadata_parser_xml.py
index 05953d4..7b55273 100755
--- a/camera/docs/metadata_parser_xml.py
+++ b/camera/docs/metadata_parser_xml.py
@@ -21,8 +21,8 @@
over a Mako template.
Usage:
- metadata_parser_xml.py <filename.xml> <template.mako>
- - outputs the resulting template to stdout
+ metadata_parser_xml.py <filename.xml> <template.mako> [<output_file>]
+ - outputs the resulting template to output_file (stdout if none specified)
Module:
The parser is also available as a module import (MetadataParserXml) to use
@@ -36,15 +36,20 @@
"""
import sys
+import os
+import StringIO
from bs4 import BeautifulSoup
from bs4 import NavigableString
from mako.template import Template
+from mako.lookup import TemplateLookup
+from mako.runtime import Context
from metadata_model import *
import metadata_model
from metadata_validate import *
+import metadata_helpers
class MetadataParserXml:
"""
@@ -102,34 +107,36 @@
for tag in tags.find_all('tag'):
self.metadata.insert_tag(tag['id'], tag.string)
- for entry in self.soup.find_all("entry"):
- d = {
- 'name': fully_qualified_name(entry),
- 'type': entry['type'],
- 'kind': find_kind(entry),
- 'type_notes': entry.attrs.get('type_notes')
- }
+ # add all entries, preserving the ordering of the XML file
+ # this is important for future ABI compatibility when generating code
+ entry_filter = lambda x: x.name == 'entry' or x.name == 'clone'
+ for entry in self.soup.find_all(entry_filter):
+ if entry.name == 'entry':
+ d = {
+ 'name': fully_qualified_name(entry),
+ 'type': entry['type'],
+ 'kind': find_kind(entry),
+ 'type_notes': entry.attrs.get('type_notes')
+ }
- d2 = self._parse_entry(entry)
+ d2 = self._parse_entry(entry)
+ insert = self.metadata.insert_entry
+ else:
+ d = {
+ 'name': entry['entry'],
+ 'kind': find_kind(entry),
+ 'target_kind': entry['kind'],
+ # no type since its the same
+ # no type_notes since its the same
+ }
+ d2 = {}
+
+ insert = self.metadata.insert_clone
+
d3 = self._parse_entry_optional(entry)
entry_dict = dict(d.items() + d2.items() + d3.items())
- self.metadata.insert_entry(entry_dict)
-
- entry = None
-
- for clone in self.soup.find_all("clone"):
- d = {
- 'name': clone['entry'],
- 'kind': find_kind(clone),
- 'target_kind': clone['kind'],
- # no type since its the same
- # no type_notes since its the same
- }
-
- d2 = self._parse_entry_optional(clone)
- clone_dict = dict(d.items() + d2.items())
- self.metadata.insert_clone(clone_dict)
+ insert(entry_dict)
self.metadata.construct_graph()
@@ -139,7 +146,7 @@
#
# Enum
#
- if entry['type'] == 'enum':
+ if entry.get('enum', 'false') == 'true':
enum_values = []
enum_optionals = []
@@ -164,6 +171,7 @@
d['enum_optionals'] = enum_optionals
d['enum_notes'] = enum_notes
d['enum_ids'] = enum_ids
+ d['enum'] = True
#
# Container (Array/Tuple)
@@ -212,12 +220,29 @@
"""
Render the metadata model using a Mako template as the view.
+ The template gets the metadata as an argument, as well as all
+ public attributes from the metadata_helpers module.
+
Args:
template: path to a Mako template file
output_name: path to the output file, or None to use stdout
"""
- tpl = Template(filename=template)
- tpl_data = tpl.render(metadata=self.metadata, metadata_model=metadata_model)
+ buf = StringIO.StringIO()
+ metadata_helpers._context_buf = buf
+
+ helpers = [(i, getattr(metadata_helpers, i))
+ for i in dir(metadata_helpers) if not i.startswith('_')]
+ helpers = dict(helpers)
+
+ lookup = TemplateLookup(directories=[os.getcwd()])
+ tpl = Template(filename=template, lookup=lookup)
+
+ ctx = Context(buf, metadata=self.metadata, **helpers)
+ tpl.render_context(ctx)
+
+ tpl_data = buf.getvalue()
+ metadata_helpers._context_buf = None
+ buf.close()
if output_name is None:
print tpl_data
@@ -228,14 +253,16 @@
#####################
if __name__ == "__main__":
- if len(sys.argv) <= 1:
- print >> sys.stderr, "Usage: %s <filename.xml> <template.mako>" \
- % (sys.argv[0])
+ if len(sys.argv) <= 2:
+ print >> sys.stderr, \
+ "Usage: %s <filename.xml> <template.mako> [<output_file>]" \
+ % (sys.argv[0])
sys.exit(0)
file_name = sys.argv[1]
template_name = sys.argv[2]
+ output_name = sys.argv[3] if len(sys.argv) > 3 else None
parser = MetadataParserXml(file_name)
- parser.render(template_name)
+ parser.render(template_name, output_name)
sys.exit(0)
diff --git a/camera/docs/metadata_properties.xml b/camera/docs/metadata_properties.xml
index 0c80cec..d0a1d33 100644
--- a/camera/docs/metadata_properties.xml
+++ b/camera/docs/metadata_properties.xml
@@ -19,19 +19,19 @@
<tags>
<tag id="AWB">
- <!-- TODO: fill the tag description -->
+ Needed for auto white balance
</tag>
<tag id="BC">
- <!-- TODO: fill the tag description -->
+ Needed for backwards compatibility with old Java API
</tag>
<tag id="V1">
- <!-- TODO: fill the tag description -->
+ New features for first camera 2 release (API1)
</tag>
<tag id="ADV">
<!-- TODO: fill the tag description -->
</tag>
<tag id="DNG">
- <!-- TODO: fill the tag description -->
+ Needed for DNG file support
</tag>
<tag id="EXIF">
<!-- TODO: fill the tag description -->
@@ -40,26 +40,28 @@
<namespace name="android">
<section name="colorCorrection">
<controls>
- <entry name="mode" type="enum">
+ <entry name="mode" type="byte" enum="true">
<enum>
<value>TRANSFORM_MATRIX
- <notes>Use the android.colorCorrection.transform matrix
- to do color conversion</notes></value>
+ <notes>Use the android.colorCorrection.transform matrix
+ to do color conversion</notes>
+ </value>
<value>FAST
- <notes>Must not slow down frame rate relative to raw
- bayer output</notes></value>
+ <notes>Must not slow down frame rate relative to raw
+ bayer output</notes>
+ </value>
<value>HIGH_QUALITY
- <notes>Frame rate may be reduced by high
- quality</notes></value>
+ <notes>Frame rate may be reduced by high
+ quality</notes>
+ </value>
</enum>
- <description>enum</description>
- <units>enum:</units>
</entry>
<entry name="transform" type="float"
type_notes="3x3 float matrix in row-major order"
container="array">
<array>
- <size>9</size>
+ <size>3</size>
+ <size>3</size>
</array>
<description>A transform matrix to chromatically adapt
pixels in the CIE XYZ (1931) color space from the scene
@@ -80,12 +82,12 @@
</section>
<section name="control">
<controls>
- <entry name="aeAntibandingMode" type="enum">
+ <entry name="aeAntibandingMode" type="byte" enum="true">
<enum>
- <value>ANTIBANDING_OFF</value>
- <value>ANTIBANDING_50HZ</value>
- <value>ANTIBANDING_60HZ</value>
- <value>ANTIBANDING_AUTO</value>
+ <value>OFF</value>
+ <value>50HZ</value>
+ <value>60HZ</value>
+ <value>AUTO</value>
</enum>
<description>Enum for controlling
antibanding</description>
@@ -101,15 +103,15 @@
compensation of -1</notes>
<tag id="BC" />
</entry>
- <entry name="aeLock" type="enum">
+ <entry name="aeLock" type="byte" enum="true">
<enum>
+ <value>OFF
+ <notes>Autoexposure lock is disabled; the AE algorithm
+ is free to update its parameters.</notes></value>
<value>ON
<notes>Autoexposure lock is enabled; the AE algorithm
must not update the exposure and sensitivity parameters
while the lock is active</notes></value>
- <value>OFF
- <notes>Autoexposure lock is disabled; the AE algorithm
- is free to update its parameters.</notes></value>
</enum>
<description>Whether AE is currently locked to its latest
calculated values</description>
@@ -118,14 +120,16 @@
ON_AUTO_FLASH_REDEYE.</notes>
<tag id="BC" />
</entry>
- <entry name="aeMode" type="enum">
+ <entry name="aeMode" type="byte" enum="true">
<enum>
<value>OFF
- <notes>Autoexposure is disabled; sensor.exposureTime
- and sensor.sensitivity are used</notes></value>
+ <notes>Autoexposure is disabled; sensor.exposureTime
+ and sensor.sensitivity are used</notes>
+ </value>
<value>ON
- <notes>Autoexposure is active, no flash
- control</notes></value>
+ <notes>Autoexposure is active, no flash
+ control</notes>
+ </value>
<value>ON_AUTO_FLASH
<notes>if flash exists Autoexposure is active, auto
flash control; flash may be fired when precapture
@@ -183,7 +187,7 @@
of android.sensor.exposureTime</notes>
<tag id="BC" />
</entry>
- <entry name="afMode" type="enum">
+ <entry name="afMode" type="byte" enum="true">
<enum>
<value>OFF
<notes>The 3A routines do not control the lens;
@@ -273,16 +277,16 @@
in the frame metadata</notes>
<tag id="BC" />
</entry>
- <entry name="awbLock" type="enum">
+ <entry name="awbLock" type="byte" enum="true">
<enum>
- <value>ON
- <notes>Auto-whitebalance lock is enabled; the AWB
- algorithm must not update the exposure and sensitivity
- parameters while the lock is active</notes></value>
<value>OFF
<notes>Auto-whitebalance lock is disabled; the AWB
algorithm is free to update its parameters if in AUTO
mode.</notes></value>
+ <value>ON
+ <notes>Auto-whitebalance lock is enabled; the AWB
+ algorithm must not update the exposure and sensitivity
+ parameters while the lock is active</notes></value>
</enum>
<description>Whether AWB is currently locked to its
latest calculated values</description>
@@ -291,7 +295,7 @@
setting</notes>
<tag id="BC" />
</entry>
- <entry name="awbMode" type="enum">
+ <entry name="awbMode" type="byte" enum="true">
<enum>
<value>OFF</value>
<value>AUTO</value>
@@ -332,26 +336,26 @@
in the frame metadata</notes>
<tag id="BC" />
</entry>
- <entry name="captureIntent" type="enum">
+ <entry name="captureIntent" type="byte" enum="true">
<enum>
- <value>INTENT_CUSTOM
+ <value>CUSTOM
<notes>This request doesn't fall into the other
categories. Default to preview-like
behavior.</notes></value>
- <value>INTENT_PREVIEW
+ <value>PREVIEW
<notes>This request is for a preview-like usecase. The
precapture trigger may be used to start off a metering
w/flash sequence</notes></value>
- <value>INTENT_STILL_CAPTURE
+ <value>STILL_CAPTURE
<notes>This request is for a still capture-type
usecase.</notes></value>
- <value>INTENT_VIDEO_RECORD
+ <value>VIDEO_RECORD
<notes>This request is for a video recording
usecase.</notes></value>
- <value>INTENT_VIDEO_SNAPSHOT
+ <value>VIDEO_SNAPSHOT
<notes>This request is for a video snapshot (still
image while recording video) usecase</notes></value>
- <value>INTENT_ZERO_SHUTTER_LAG
+ <value>ZERO_SHUTTER_LAG
<notes>This request is for a ZSL usecase; the
application will stream full-resolution images and
reprocess one or several later for a final
@@ -364,24 +368,24 @@
<notes>Only used if android.control.mode != OFF.</notes>
<tag id="BC" />
</entry>
- <entry name="effectMode" type="enum">
+ <entry name="effectMode" type="byte" enum="true">
<enum>
- <value>EFFECT_OFF</value>
- <value optional="true">EFFECT_MONO</value>
- <value optional="true">EFFECT_NEGATIVE</value>
- <value optional="true">EFFECT_SOLARIZE</value>
- <value optional="true">EFFECT_SEPIA</value>
- <value optional="true">EFFECT_POSTERIZE</value>
- <value optional="true">EFFECT_WHITEBOARD</value>
- <value optional="true">EFFECT_BLACKBOARD</value>
- <value optional="true">EFFECT_AQUA</value>
+ <value>OFF</value>
+ <value optional="true">MONO</value>
+ <value optional="true">NEGATIVE</value>
+ <value optional="true">SOLARIZE</value>
+ <value optional="true">SEPIA</value>
+ <value optional="true">POSTERIZE</value>
+ <value optional="true">WHITEBOARD</value>
+ <value optional="true">BLACKBOARD</value>
+ <value optional="true">AQUA</value>
</enum>
<description>Whether any special color effect is in use.
Only used if android.control.mode != OFF</description>
<range>android.control.availableEffects</range>
<tag id="BC" />
</entry>
- <entry name="mode" type="enum">
+ <entry name="mode" type="byte" enum="true">
<enum>
<value>OFF
<notes>Full application control of pipeline. All 3A
@@ -406,9 +410,10 @@
<range>all must be supported</range>
<tag id="BC" />
</entry>
- <entry name="sceneMode" type="enum">
+ <entry name="sceneMode" type="byte" enum="true">
<enum>
- <value>SCENE_MODE_FACE_PRIORITY
+ <value id="0">UNSUPPORTED</value>
+ <value>FACE_PRIORITY
<notes>if face detection support exists Use face
detection data to drive 3A routines. If face detection
statistics are disabled, should still operate correctly
@@ -417,29 +422,28 @@
awbMode, and afMode remain active when FACE_PRIORITY is
set. This is due to compatibility concerns with the old
camera API</notes></value>
- <value optional="true">SCENE_MODE_ACTION</value>
- <value optional="true">SCENE_MODE_PORTRAIT</value>
- <value optional="true">SCENE_MODE_LANDSCAPE</value>
- <value optional="true">SCENE_MODE_NIGHT</value>
- <value optional="true">
- SCENE_MODE_NIGHT_PORTRAIT</value>
- <value optional="true">SCENE_MODE_THEATRE</value>
- <value optional="true">SCENE_MODE_BEACH</value>
- <value optional="true">SCENE_MODE_SNOW</value>
- <value optional="true">SCENE_MODE_SUNSET</value>
- <value optional="true">SCENE_MODE_STEADYPHOTO</value>
- <value optional="true">SCENE_MODE_FIREWORKS</value>
- <value optional="true">SCENE_MODE_SPORTS</value>
- <value optional="true">SCENE_MODE_PARTY</value>
- <value optional="true">SCENE_MODE_CANDLELIGHT</value>
- <value optional="true">SCENE_MODE_BARCODE</value>
+ <value optional="true">ACTION</value>
+ <value optional="true">PORTRAIT</value>
+ <value optional="true">LANDSCAPE</value>
+ <value optional="true">NIGHT</value>
+ <value optional="true">NIGHT_PORTRAIT</value>
+ <value optional="true">THEATRE</value>
+ <value optional="true">BEACH</value>
+ <value optional="true">SNOW</value>
+ <value optional="true">SUNSET</value>
+ <value optional="true">STEADYPHOTO</value>
+ <value optional="true">FIREWORKS</value>
+ <value optional="true">SPORTS</value>
+ <value optional="true">PARTY</value>
+ <value optional="true">CANDLELIGHT</value>
+ <value optional="true">BARCODE</value>
</enum>
<description>Which scene mode is active when
android.control.mode = SCENE_MODE</description>
<range>android.control.availableSceneModes</range>
<tag id="BC" />
</entry>
- <entry name="videoStabilizationMode" type="enum">
+ <entry name="videoStabilizationMode" type="byte" enum="true">
<enum>
<value>OFF</value>
<value>ON</value>
@@ -597,7 +601,7 @@
</entry>
<clone entry="android.control.aeRegions" kind="controls">
</clone>
- <entry name="aeState" type="enum">
+ <entry name="aeState" type="byte" enum="true">
<enum>
<value>INACTIVE
<notes>AE is off</notes></value>
@@ -631,7 +635,7 @@
</clone>
<clone entry="android.control.afRegions" kind="controls">
</clone>
- <entry name="afState" type="enum">
+ <entry name="afState" type="byte" enum="true">
<enum>
<value>INACTIVE
<notes>AF off or has not yet tried to scan/been asked
@@ -648,11 +652,11 @@
<notes>if AUTO or MACRO modes are supported AF is doing
an AF scan because it was triggered by AF
trigger</notes></value>
- <value>AF_FOCUSED_LOCKED
+ <value>FOCUSED_LOCKED
<notes>if any AF mode besides OFF is supported AF
believes it is focused correctly and is
locked</notes></value>
- <value>AF_NOT_FOCUSED_LOCKED
+ <value>NOT_FOCUSED_LOCKED
<notes>if any AF mode besides OFF is supported AF has
failed to focus successfully and is
locked</notes></value>
@@ -673,7 +677,7 @@
</clone>
<clone entry="android.control.awbRegions" kind="controls">
</clone>
- <entry name="awbState" type="enum">
+ <entry name="awbState" type="byte" enum="true">
<enum>
<value>INACTIVE
<notes>AWB is not in auto mode</notes></value>
@@ -698,7 +702,7 @@
</section>
<section name="demosaic">
<controls>
- <entry name="mode" type="enum">
+ <entry name="mode" type="byte" enum="true">
<enum>
<value>FAST
<notes>Minimal or no slowdown of frame rate compared to
@@ -709,14 +713,13 @@
</enum>
<description>Controls the quality of the demosaicing
processing</description>
- <units>Enum:</units>
<tag id="V1" />
</entry>
</controls>
</section>
<section name="edge">
<controls>
- <entry name="mode" type="enum">
+ <entry name="mode" type="byte" enum="true">
<enum>
<value>OFF
<notes>No edge enhancement is applied</notes></value>
@@ -729,7 +732,6 @@
</enum>
<description>Operation mode for edge
enhancement</description>
- <units>enum:</units>
</entry>
<entry name="strength" type="byte">
<description>Control the amount of edge enhancement
@@ -761,7 +763,7 @@
duration).</notes>
<tag id="V1" />
</entry>
- <entry name="mode" type="enum">
+ <entry name="mode" type="byte" enum="true">
<enum>
<value>OFF
<notes>Do not fire the flash for this
@@ -776,7 +778,6 @@
firingPower</notes></value>
</enum>
<description>Select flash operation mode</description>
- <units>enum</units>
<tag id="BC" />
</entry>
</controls>
@@ -821,7 +822,7 @@
<clone entry="android.flash.firingTime" kind="controls">
</clone>
<clone entry="android.flash.mode" kind="controls"></clone>
- <entry name="state" type="enum">
+ <entry name="state" type="byte" enum="true">
<enum>
<value>UNAVAILABLE
<notes>No flash on camera</notes></value>
@@ -837,13 +838,12 @@
</enum>
<description>Current state of the flash
unit</description>
- <units>enum</units>
</entry>
</dynamic>
</section>
<section name="geometric">
<controls>
- <entry name="mode" type="enum">
+ <entry name="mode" type="byte" enum="true">
<enum>
<value>OFF
<notes>No geometric correction is
@@ -857,7 +857,6 @@
</enum>
<description>Operating mode of geometric
correction</description>
- <units>enum:</units>
</entry>
<entry name="strength" type="byte">
<description>Control the amount of shading correction
@@ -868,7 +867,25 @@
</entry>
</controls>
</section>
- <section name="hotPIxel">
+ <section name="hotPixel">
+ <controls>
+ <entry name="mode" type="byte" enum="true">
+ <enum>
+ <value>OFF
+ <notes>No hot pixel correction can be
+ applied</notes></value>
+ <value>FAST
+ <notes>Frame rate must not be reduced compared to raw
+ Bayer output</notes></value>
+ <value>HIGH_QUALITY
+ <notes>Frame rate may be reduced by high
+ quality</notes></value>
+ </enum>
+ <description>Set operational mode for hot pixel
+ correction</description>
+ <tag id="V1" />
+ </entry>
+ </controls>
<static>
<namespace name="info">
<entry name="map" type="int32"
@@ -884,27 +901,6 @@
</entry>
</namespace>
</static>
- </section>
- <section name="hotPixel">
- <controls>
- <entry name="mode" type="enum">
- <enum>
- <value>OFF
- <notes>No hot pixel correction can be
- applied</notes></value>
- <value>FAST
- <notes>Frame rate must not be reduced compared to raw
- Bayer output</notes></value>
- <value>HIGH_QUALITY
- <notes>Frame rate may be reduced by high
- quality</notes></value>
- </enum>
- <description>Set operational mode for hot pixel
- correction</description>
- <units>Enum:</units>
- <tag id="V1" />
- </entry>
- </controls>
<dynamic>
<clone entry="android.hotPixel.mode" kind="controls">
<tag id="V1" />
@@ -1054,14 +1050,13 @@
<tag id="BC" />
<tag id="V1" />
</entry>
- <entry name="opticalStabilizationMode" type="enum">
+ <entry name="opticalStabilizationMode" type="byte" enum="true">
<enum>
<value>OFF</value>
<value optional="true">ON</value>
</enum>
<description>Whether optical image stabilization is
enabled.</description>
- <units>enum</units>
<range>android.lens.availableOpticalStabilization</range>
<notes>Will not be supported on most devices.</notes>
<tag id="V1" />
@@ -1197,15 +1192,13 @@
<tag id="V1" />
</entry>
</namespace>
- <entry name="facing" type="enum">
+ <entry name="facing" type="byte" enum="true">
<enum>
- <value>FACING_FRONT</value>
- <value>FACING_BACK</value>
+ <value>FRONT</value>
+ <value>BACK</value>
</enum>
<description>Direction the camera faces relative to
device screen</description>
- <units>enum</units>
- <notes>}</notes>
</entry>
<entry name="opticalAxisAngle" type="float"
type_notes="degrees. First defines the angle of separation between the perpendicular to the screen and the camera optical axis. The second then defines the clockwise rotation of the optical axis from native device up."
@@ -1263,7 +1256,7 @@
kind="controls">
<tag id="V1" />
</clone>
- <entry name="state" type="enum">
+ <entry name="state" type="byte" enum="true">
<enum>
<value>STATIONARY</value>
</enum>
@@ -1274,7 +1267,7 @@
</section>
<section name="noiseReduction">
<controls>
- <entry name="mode" type="enum">
+ <entry name="mode" type="byte" enum="true">
<enum>
<value>OFF
<notes>No noise reduction is applied</notes></value>
@@ -1287,7 +1280,6 @@
</enum>
<description>Mode of operation for the noise reduction
algorithm</description>
- <units>enum:</units>
<range>android.noiseReduction.availableModes</range>
<tag id="V1" />
</entry>
@@ -1370,7 +1362,7 @@
<notes>Only meaningful when android.request.type ==
REPROCESS. Ignored otherwise</notes>
</entry>
- <entry name="metadataMode" type="enum">
+ <entry name="metadataMode" type="byte" enum="true">
<enum>
<value>NONE
<notes>No metadata should be produced on output, except
@@ -1388,7 +1380,6 @@
</enum>
<description>How much metadata to produce on
output</description>
- <units>Enum:</units>
</entry>
<entry name="outputStreams" type="byte">
<description>Lists which camera output streams image data
@@ -1401,7 +1392,7 @@
still be captured for metadata and statistics production,
and the lens and flash must operate as requested.</notes>
</entry>
- <entry name="type" type="enum">
+ <entry name="type" type="byte" enum="true">
<enum>
<value>CAPTURE
<notes>Capture a new image from the imaging hardware,
@@ -1415,7 +1406,6 @@
</enum>
<description>The type of the request; either CAPTURE or
REPROCESS</description>
- <units>Enum:</units>
</entry>
</controls>
<static>
@@ -1483,7 +1473,7 @@
</entry>
</controls>
<static>
- <entry name="availableFormats" type="enum"
+ <entry name="availableFormats" type="int32" enum="true"
type_notes="values from HAL_PIXEL_FORMAT_* in /system/core/include/system/graphics.h"
container="array">
<array>
@@ -1532,6 +1522,9 @@
include: - half/quarter max resolution</range>
<tag id="BC" />
</entry>
+ <entry name="availableMaxDigitalZoom" type="int32">
+ <description>TODO: have a real description here</description>
+ </entry>
<entry name="availableProcessedMinDurations" type="int64"
container="array">
<array>
@@ -1659,7 +1652,7 @@
<tag id="BC" />
<tag id="V1" />
</entry>
- <entry name="colorFilterArrangement" type="enum">
+ <entry name="colorFilterArrangement" type="byte" enum="true">
<enum>
<value>RGGB</value>
<value>GRBG</value>
@@ -1851,7 +1844,7 @@
<range>0,90,180,270</range>
<tag id="BC" />
</entry>
- <entry name="referenceIlluminant1" type="enum">
+ <entry name="referenceIlluminant1" type="byte" enum="true">
<enum>
<value id="1">DAYLIGHT</value>
<value id="2">FLUORESCENT</value>
@@ -1911,7 +1904,7 @@
</section>
<section name="shading">
<controls>
- <entry name="mode" type="enum">
+ <entry name="mode" type="byte" enum="true">
<enum>
<value>OFF
<notes>No shading correction is applied</notes></value>
@@ -1924,7 +1917,6 @@
</enum>
<description>Quality of lens shading correction applied
to the image data</description>
- <units>enum:</units>
</entry>
<entry name="strength" type="byte">
<description>Control the amount of shading correction
@@ -1941,7 +1933,7 @@
</section>
<section name="statistics">
<controls>
- <entry name="faceDetectMode" type="enum">
+ <entry name="faceDetectMode" type="byte" enum="true">
<enum>
<value>OFF</value>
<value>SIMPLE
@@ -1953,29 +1945,26 @@
</enum>
<description>State of the face detector
unit</description>
- <units>enum</units>
<range>
android.statistics.availableFaceDetectModes</range>
<tag id="BC" />
</entry>
- <entry name="histogramMode" type="enum">
+ <entry name="histogramMode" type="byte" enum="true">
<enum>
<value>OFF</value>
<value>ON</value>
</enum>
<description>Operating mode for histogram
generation</description>
- <units>enum</units>
<tag id="V1" />
</entry>
- <entry name="sharpnessMapMode" type="enum">
+ <entry name="sharpnessMapMode" type="byte" enum="true">
<enum>
<value>OFF</value>
<value>ON</value>
</enum>
<description>Operating mode for sharpness map
generation</description>
- <units>enum</units>
<tag id="V1" />
</entry>
</controls>
@@ -2103,13 +2092,13 @@
</section>
<section name="tonemap">
<controls>
- <entry name="curveBlue" type="byte">
+ <entry name="curveBlue" type="float">
<description>Table mapping blue input values to output
values</description>
<units>same as android.tonemap.curveRed</units>
<range>same as android.tonemap.curveRed</range>
</entry>
- <entry name="curveGreen" type="byte">
+ <entry name="curveGreen" type="float">
<description>Table mapping green input values to output
values</description>
<units>same as android.tonemap.curveRed</units>
@@ -2134,7 +2123,7 @@
0.25, 0.3 -> 0.5, 0.5 -> 0.64</notes>
<tag id="DNG" />
</entry>
- <entry name="mode" type="enum">
+ <entry name="mode" type="byte" enum="true">
<enum>
<value>CONTRAST_CURVE
<notes>Use the tone mapping curve specified in
@@ -2146,7 +2135,6 @@
<notes>Frame rate may be reduced by high
quality</notes></value>
</enum>
- <units>enum:</units>
</entry>
</controls>
<static>
diff --git a/camera/docs/metadata_properties.xsd b/camera/docs/metadata_properties.xsd
index 8159e45..259aebf 100644
--- a/camera/docs/metadata_properties.xsd
+++ b/camera/docs/metadata_properties.xsd
@@ -37,11 +37,13 @@
</complexType>
<complexType name="SectionType">
- <all>
- <element name="controls" type="tns:SectionKindType" maxOccurs="1" minOccurs="0"></element>
- <element name="static" type="tns:SectionKindType" maxOccurs="1" minOccurs="0"></element>
- <element name="dynamic" type="tns:SectionKindType" maxOccurs="1" minOccurs="0"></element>
- </all>
+ <sequence>
+ <choice maxOccurs="unbounded">
+ <element name="controls" type="tns:SectionKindType" maxOccurs="unbounded" minOccurs="0"></element>
+ <element name="static" type="tns:SectionKindType" maxOccurs="unbounded" minOccurs="0"></element>
+ <element name="dynamic" type="tns:SectionKindType" maxOccurs="unbounded" minOccurs="0"></element>
+ </choice>
+ </sequence>
<attribute name="name" type="string" use="required"></attribute>
</complexType>
@@ -124,7 +126,6 @@
<enumeration value="float" />
<enumeration value="double" />
<enumeration value="rational" />
- <enumeration value="enum" />
</restriction>
</simpleType>
</attribute>
@@ -137,6 +138,14 @@
</restriction>
</simpleType>
</attribute>
+ <attribute name="enum">
+ <simpleType>
+ <restriction base="string">
+ <enumeration value="true"></enumeration>
+ <enumeration value="false"></enumeration>
+ </restriction>
+ </simpleType>
+ </attribute>
</complexType>
<complexType name="EnumType">
diff --git a/camera/docs/metadata_template.mako b/camera/docs/metadata_template.mako
index 6fb1b02..253db61 100644
--- a/camera/docs/metadata_template.mako
+++ b/camera/docs/metadata_template.mako
@@ -21,7 +21,11 @@
<tags>
% for tag in metadata.tags:
+ % if tag.description and tag.description.strip():
+ <tag id="${tag.id}">${tag.description | x}</tag>
+ % else:
<tag id="${tag.id}"><!-- TODO: fill the tag description --></tag>
+ % endif
% endfor
</tags>
@@ -68,6 +72,9 @@
</clone>
% else:
<entry name="${prop.name_short}" type="${prop.type}"
+ % if prop.enum:
+ enum="true"
+ % endif
% if prop.type_notes is not None:
type_notes="${prop.type_notes}"
% endif
@@ -89,7 +96,7 @@
% endfor
</tuple>
% endif
- % if prop.type == 'enum':
+ % if prop.enum:
<enum>
% for value in prop.enum.values:
<value
diff --git a/camera/docs/metadata_validate.py b/camera/docs/metadata_validate.py
index 6c9c408..0dc4ae9 100755
--- a/camera/docs/metadata_validate.py
+++ b/camera/docs/metadata_validate.py
@@ -236,15 +236,15 @@
%(fully_qualified_name(entry), find_kind(entry), \
entry_container, entry_container))
- typ = entry.attrs.get('type')
- if typ == 'enum':
+ enum = entry.attrs.get('enum')
+ if enum and enum == 'true':
if entry.enum is None:
validate_error(("Entry '%s' in kind '%s' is missing enum") \
% (fully_qualified_name(entry), find_kind(entry),
))
+ success = False
- if typ == 'enum' and entry.enum is not None:
-
+ else:
for value in entry.enum.find_all('value'):
value_id = value.attrs.get('id')
@@ -256,6 +256,12 @@
" numeric.") \
%(fully_qualified_name(entry), value_id))
success = False
+ else:
+ if entry.enum:
+ validate_error(("Entry '%s' kind '%s' has enum el, but no enum attr") \
+ % (fully_qualified_name(entry), find_kind(entry),
+ ))
+ success = False
return success
diff --git a/camera/include/system/camera_metadata_tags.h b/camera/include/system/camera_metadata_tags.h
index 796e571..8d20ae8 100644
--- a/camera/include/system/camera_metadata_tags.h
+++ b/camera/include/system/camera_metadata_tags.h
@@ -20,6 +20,12 @@
* Include camera_metadata.h instead.
*/
+/**
+ * ! Do not edit this file directly !
+ *
+ * Generated automatically from camera_metadata_tags.mako
+ */
+
/** TODO: Nearly every enum in this file needs a description */
/**
@@ -28,83 +34,63 @@
* New sections must be added right before ANDROID_SECTION_COUNT to maintain
* existing enumerations.
*/
-enum {
- ANDROID_REQUEST = 0,
- ANDROID_LENS,
- ANDROID_LENS_INFO,
- ANDROID_SENSOR,
- ANDROID_SENSOR_INFO,
+typedef enum camera_metadata_section {
+ ANDROID_COLOR_CORRECTION,
+ ANDROID_CONTROL,
+ ANDROID_DEMOSAIC,
+ ANDROID_EDGE,
ANDROID_FLASH,
ANDROID_FLASH_INFO,
+ ANDROID_GEOMETRIC,
ANDROID_HOT_PIXEL,
ANDROID_HOT_PIXEL_INFO,
- ANDROID_DEMOSAIC,
- ANDROID_DEMOSAIC_INFO,
- ANDROID_NOISE,
- ANDROID_NOISE_INFO,
- ANDROID_SHADING,
- ANDROID_SHADING_INFO,
- ANDROID_GEOMETRIC,
- ANDROID_GEOMETRIC_INFO,
- ANDROID_COLOR,
- ANDROID_COLOR_INFO,
- ANDROID_TONEMAP,
- ANDROID_TONEMAP_INFO,
- ANDROID_EDGE,
- ANDROID_EDGE_INFO,
- ANDROID_SCALER,
- ANDROID_SCALER_INFO,
ANDROID_JPEG,
- ANDROID_JPEG_INFO,
- ANDROID_STATS,
- ANDROID_STATS_INFO,
- ANDROID_CONTROL,
- ANDROID_CONTROL_INFO,
- ANDROID_QUIRKS_INFO,
+ ANDROID_LENS,
+ ANDROID_LENS_INFO,
+ ANDROID_NOISE_REDUCTION,
+ ANDROID_QUIRKS,
+ ANDROID_REQUEST,
+ ANDROID_SCALER,
+ ANDROID_SENSOR,
+ ANDROID_SENSOR_INFO,
+ ANDROID_SHADING,
+ ANDROID_STATISTICS,
+ ANDROID_STATISTICS_INFO,
+ ANDROID_TONEMAP,
ANDROID_SECTION_COUNT,
VENDOR_SECTION = 0x8000
-};
+} camera_metadata_section_t;
/**
* Hierarchy positions in enum space. All vendor extension tags must be
* defined with tag >= VENDOR_SECTION_START
*/
-enum {
- ANDROID_REQUEST_START = ANDROID_REQUEST << 16,
- ANDROID_LENS_START = ANDROID_LENS << 16,
- ANDROID_LENS_INFO_START = ANDROID_LENS_INFO << 16,
- ANDROID_SENSOR_START = ANDROID_SENSOR << 16,
- ANDROID_SENSOR_INFO_START = ANDROID_SENSOR_INFO << 16,
- ANDROID_FLASH_START = ANDROID_FLASH << 16,
- ANDROID_FLASH_INFO_START = ANDROID_FLASH_INFO << 16,
- ANDROID_HOT_PIXEL_START = ANDROID_HOT_PIXEL << 16,
- ANDROID_HOT_PIXEL_INFO_START = ANDROID_HOT_PIXEL_INFO << 16,
- ANDROID_DEMOSAIC_START = ANDROID_DEMOSAIC << 16,
- ANDROID_DEMOSAIC_INFO_START = ANDROID_DEMOSAIC_INFO << 16,
- ANDROID_NOISE_START = ANDROID_NOISE << 16,
- ANDROID_NOISE_INFO_START = ANDROID_NOISE_INFO << 16,
- ANDROID_SHADING_START = ANDROID_SHADING << 16,
- ANDROID_SHADING_INFO_START = ANDROID_SHADING_INFO << 16,
- ANDROID_GEOMETRIC_START = ANDROID_GEOMETRIC << 16,
- ANDROID_GEOMETRIC_INFO_START = ANDROID_GEOMETRIC_INFO << 16,
- ANDROID_COLOR_START = ANDROID_COLOR << 16,
- ANDROID_COLOR_INFO_START = ANDROID_COLOR_INFO << 16,
- ANDROID_TONEMAP_START = ANDROID_TONEMAP << 16,
- ANDROID_TONEMAP_INFO_START = ANDROID_TONEMAP_INFO << 16,
- ANDROID_EDGE_START = ANDROID_EDGE << 16,
- ANDROID_EDGE_INFO_START = ANDROID_EDGE_INFO << 16,
- ANDROID_SCALER_START = ANDROID_SCALER << 16,
- ANDROID_SCALER_INFO_START = ANDROID_SCALER_INFO << 16,
- ANDROID_JPEG_START = ANDROID_JPEG << 16,
- ANDROID_JPEG_INFO_START = ANDROID_JPEG_INFO << 16,
- ANDROID_STATS_START = ANDROID_STATS << 16,
- ANDROID_STATS_INFO_START = ANDROID_STATS_INFO << 16,
- ANDROID_CONTROL_START = ANDROID_CONTROL << 16,
- ANDROID_CONTROL_INFO_START = ANDROID_CONTROL_INFO << 16,
- ANDROID_QUIRKS_INFO_START = ANDROID_QUIRKS_INFO << 16,
- VENDOR_SECTION_START = VENDOR_SECTION << 16
-};
+typedef enum camera_metadata_section_start {
+ ANDROID_COLOR_CORRECTION_START = ANDROID_COLOR_CORRECTION << 16,
+ ANDROID_CONTROL_START = ANDROID_CONTROL << 16,
+ ANDROID_DEMOSAIC_START = ANDROID_DEMOSAIC << 16,
+ ANDROID_EDGE_START = ANDROID_EDGE << 16,
+ ANDROID_FLASH_START = ANDROID_FLASH << 16,
+ ANDROID_FLASH_INFO_START = ANDROID_FLASH_INFO << 16,
+ ANDROID_GEOMETRIC_START = ANDROID_GEOMETRIC << 16,
+ ANDROID_HOT_PIXEL_START = ANDROID_HOT_PIXEL << 16,
+ ANDROID_HOT_PIXEL_INFO_START = ANDROID_HOT_PIXEL_INFO << 16,
+ ANDROID_JPEG_START = ANDROID_JPEG << 16,
+ ANDROID_LENS_START = ANDROID_LENS << 16,
+ ANDROID_LENS_INFO_START = ANDROID_LENS_INFO << 16,
+ ANDROID_NOISE_REDUCTION_START = ANDROID_NOISE_REDUCTION << 16,
+ ANDROID_QUIRKS_START = ANDROID_QUIRKS << 16,
+ ANDROID_REQUEST_START = ANDROID_REQUEST << 16,
+ ANDROID_SCALER_START = ANDROID_SCALER << 16,
+ ANDROID_SENSOR_START = ANDROID_SENSOR << 16,
+ ANDROID_SENSOR_INFO_START = ANDROID_SENSOR_INFO << 16,
+ ANDROID_SHADING_START = ANDROID_SHADING << 16,
+ ANDROID_STATISTICS_START = ANDROID_STATISTICS << 16,
+ ANDROID_STATISTICS_INFO_START = ANDROID_STATISTICS_INFO << 16,
+ ANDROID_TONEMAP_START = ANDROID_TONEMAP << 16,
+ VENDOR_SECTION_START = VENDOR_SECTION << 16
+} camera_metadata_section_start_t;
/**
* Main enum for defining camera metadata tags. New entries must always go
@@ -112,318 +98,306 @@
* addition, the name and type of the tag needs to be added to
* system/media/camera/src/camera_metadata_tag_info.c
*/
-enum {
- ANDROID_REQUEST_ID = ANDROID_REQUEST_START,
- ANDROID_REQUEST_TYPE,
- ANDROID_REQUEST_METADATA_MODE,
- ANDROID_REQUEST_OUTPUT_STREAMS,
- ANDROID_REQUEST_INPUT_STREAMS,
- ANDROID_REQUEST_FRAME_COUNT,
- ANDROID_REQUEST_END,
+typedef enum camera_metadata_tag {
+ ANDROID_COLOR_CORRECTION_MODE = ANDROID_COLOR_CORRECTION_START,
+ ANDROID_COLOR_CORRECTION_TRANSFORM,
+ ANDROID_COLOR_CORRECTION_END,
- ANDROID_LENS_FOCUS_DISTANCE = ANDROID_LENS_START,
- ANDROID_LENS_APERTURE,
- ANDROID_LENS_FOCAL_LENGTH,
- ANDROID_LENS_FILTER_DENSITY,
- ANDROID_LENS_OPTICAL_STABILIZATION_MODE,
- ANDROID_LENS_FOCUS_RANGE,
- ANDROID_LENS_END,
+ ANDROID_CONTROL_AE_ANTIBANDING_MODE
+ = ANDROID_CONTROL_START,
+ ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION,
+ ANDROID_CONTROL_AE_LOCK,
+ ANDROID_CONTROL_AE_MODE,
+ ANDROID_CONTROL_AE_REGIONS,
+ ANDROID_CONTROL_AE_TARGET_FPS_RANGE,
+ ANDROID_CONTROL_AF_MODE,
+ ANDROID_CONTROL_AF_REGIONS,
+ ANDROID_CONTROL_AWB_LOCK,
+ ANDROID_CONTROL_AWB_MODE,
+ ANDROID_CONTROL_AWB_REGIONS,
+ ANDROID_CONTROL_CAPTURE_INTENT,
+ ANDROID_CONTROL_EFFECT_MODE,
+ ANDROID_CONTROL_MODE,
+ ANDROID_CONTROL_SCENE_MODE,
+ ANDROID_CONTROL_VIDEO_STABILIZATION_MODE,
+ ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES,
+ ANDROID_CONTROL_AE_AVAILABLE_MODES,
+ ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
+ ANDROID_CONTROL_AE_COMPENSATION_RANGE,
+ ANDROID_CONTROL_AE_COMPENSATION_STEP,
+ ANDROID_CONTROL_AF_AVAILABLE_MODES,
+ ANDROID_CONTROL_AVAILABLE_EFFECTS,
+ ANDROID_CONTROL_AVAILABLE_SCENE_MODES,
+ ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES,
+ ANDROID_CONTROL_AWB_AVAILABLE_MODES,
+ ANDROID_CONTROL_MAX_REGIONS,
+ ANDROID_CONTROL_SCENE_MODE_OVERRIDES,
+ ANDROID_CONTROL_AE_PRECAPTURE_ID,
+ ANDROID_CONTROL_AE_STATE,
+ ANDROID_CONTROL_AF_STATE,
+ ANDROID_CONTROL_AF_TRIGGER_ID,
+ ANDROID_CONTROL_AWB_STATE,
+ ANDROID_CONTROL_END,
- ANDROID_LENS_MINIMUM_FOCUS_DISTANCE = ANDROID_LENS_INFO_START,
- ANDROID_LENS_HYPERFOCAL_DISTANCE,
- ANDROID_LENS_AVAILABLE_FOCAL_LENGTHS,
- ANDROID_LENS_AVAILABLE_APERTURES,
- ANDROID_LENS_AVAILABLE_FILTER_DENSITY,
- ANDROID_LENS_AVAILABLE_OPTICAL_STABILIZATION,
- ANDROID_LENS_SHADING_MAP_SIZE,
- ANDROID_LENS_SHADING_MAP,
- ANDROID_LENS_GEOMETRIC_CORRECTION_MAP_SIZE,
- ANDROID_LENS_GEOMETRIC_CORRECTION_MAP,
- ANDROID_LENS_FACING,
- ANDROID_LENS_POSITION,
- ANDROID_LENS_INFO_END,
-
- ANDROID_SENSOR_EXPOSURE_TIME = ANDROID_SENSOR_START,
- ANDROID_SENSOR_FRAME_DURATION,
- ANDROID_SENSOR_SENSITIVITY,
- ANDROID_SENSOR_TIMESTAMP,
- ANDROID_SENSOR_END,
-
- ANDROID_SENSOR_EXPOSURE_TIME_RANGE = ANDROID_SENSOR_INFO_START,
- ANDROID_SENSOR_MAX_FRAME_DURATION,
- ANDROID_SENSOR_AVAILABLE_SENSITIVITIES,
- ANDROID_SENSOR_COLOR_FILTER_ARRANGEMENT,
- ANDROID_SENSOR_PHYSICAL_SIZE,
- ANDROID_SENSOR_PIXEL_ARRAY_SIZE,
- ANDROID_SENSOR_ACTIVE_ARRAY_SIZE,
- ANDROID_SENSOR_WHITE_LEVEL,
- ANDROID_SENSOR_BLACK_LEVEL_PATTERN,
- ANDROID_SENSOR_COLOR_TRANSFORM_1,
- ANDROID_SENSOR_COLOR_TRANSFORM_2,
- ANDROID_SENSOR_REFERENCE_ILLUMINANT_1,
- ANDROID_SENSOR_REFERENCE_ILLUMINANT_2,
- ANDROID_SENSOR_FORWARD_MATRIX_1,
- ANDROID_SENSOR_FORWARD_MATRIX_2,
- ANDROID_SENSOR_CALIBRATION_TRANSFORM_1,
- ANDROID_SENSOR_CALIBRATION_TRANSFORM_2,
- ANDROID_SENSOR_BASE_GAIN_FACTOR,
- ANDROID_SENSOR_MAX_ANALOG_SENSITIVITY,
- ANDROID_SENSOR_NOISE_MODEL_COEFFICIENTS,
- ANDROID_SENSOR_ORIENTATION,
- ANDROID_SENSOR_INFO_END,
-
- ANDROID_FLASH_MODE = ANDROID_FLASH_START,
- ANDROID_FLASH_FIRING_POWER,
- ANDROID_FLASH_FIRING_TIME,
- ANDROID_FLASH_END,
-
- ANDROID_FLASH_AVAILABLE = ANDROID_FLASH_INFO_START,
- ANDROID_FLASH_CHARGE_DURATION,
- ANDROID_FLASH_INFO_END,
-
- ANDROID_HOT_PIXEL_MODE = ANDROID_HOT_PIXEL_START,
- ANDROID_HOT_PIXEL_END,
-
- ANDROID_HOT_PIXEL_INFO_END = ANDROID_HOT_PIXEL_INFO_START,
-
- ANDROID_DEMOSAIC_MODE = ANDROID_DEMOSAIC_START,
+ ANDROID_DEMOSAIC_MODE = ANDROID_DEMOSAIC_START,
ANDROID_DEMOSAIC_END,
- ANDROID_DEMOSAIC_INFO_END = ANDROID_DEMOSAIC_INFO_START,
-
- ANDROID_NOISE_MODE = ANDROID_NOISE_START,
- ANDROID_NOISE_STRENGTH,
- ANDROID_NOISE_END,
-
- ANDROID_NOISE_INFO_END = ANDROID_NOISE_INFO_START,
-
- ANDROID_SHADING_MODE = ANDROID_SHADING_START,
- ANDROID_SHADING_END,
-
- ANDROID_SHADING_INFO_END = ANDROID_SHADING_INFO_START,
-
- ANDROID_GEOMETRIC_MODE = ANDROID_GEOMETRIC_START,
- ANDROID_GEOMETRIC_END,
-
- ANDROID_GEOMETRIC_INFO_END = ANDROID_GEOMETRIC_INFO_START,
-
- ANDROID_COLOR_MODE = ANDROID_COLOR_START,
- ANDROID_COLOR_TRANSFORM,
- ANDROID_COLOR_END,
-
- ANDROID_COLOR_INFO_END = ANDROID_COLOR_INFO_START,
-
- ANDROID_TONEMAP_MODE = ANDROID_TONEMAP_START,
- ANDROID_TONEMAP_CURVE_RED,
- ANDROID_TONEMAP_CURVE_GREEN,
- ANDROID_TONEMAP_CURVE_BLUE,
- ANDROID_TONEMAP_END,
-
- ANDROID_TONEMAP_MAX_CURVE_POINTS = ANDROID_TONEMAP_INFO_START,
- ANDROID_TONEMAP_INFO_END,
-
- ANDROID_EDGE_MODE = ANDROID_EDGE_START,
+ ANDROID_EDGE_MODE = ANDROID_EDGE_START,
ANDROID_EDGE_STRENGTH,
ANDROID_EDGE_END,
- ANDROID_EDGE_INFO_END = ANDROID_EDGE_INFO_START,
+ ANDROID_FLASH_FIRING_POWER = ANDROID_FLASH_START,
+ ANDROID_FLASH_FIRING_TIME,
+ ANDROID_FLASH_MODE,
+ ANDROID_FLASH_COLOR_TEMPERATURE,
+ ANDROID_FLASH_MAX_ENERGY,
+ ANDROID_FLASH_STATE,
+ ANDROID_FLASH_END,
- ANDROID_SCALER_CROP_REGION = ANDROID_SCALER_START,
- ANDROID_SCALER_END,
+ ANDROID_FLASH_INFO_AVAILABLE = ANDROID_FLASH_INFO_START,
+ ANDROID_FLASH_INFO_CHARGE_DURATION,
+ ANDROID_FLASH_INFO_END,
- ANDROID_SCALER_AVAILABLE_FORMATS = ANDROID_SCALER_INFO_START,
- ANDROID_SCALER_AVAILABLE_RAW_SIZES,
- ANDROID_SCALER_AVAILABLE_RAW_MIN_DURATIONS,
- ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES,
- ANDROID_SCALER_AVAILABLE_PROCESSED_MIN_DURATIONS,
- ANDROID_SCALER_AVAILABLE_JPEG_SIZES,
- ANDROID_SCALER_AVAILABLE_JPEG_MIN_DURATIONS,
- ANDROID_SCALER_AVAILABLE_MAX_ZOOM,
- ANDROID_SCALER_INFO_END,
+ ANDROID_GEOMETRIC_MODE = ANDROID_GEOMETRIC_START,
+ ANDROID_GEOMETRIC_STRENGTH,
+ ANDROID_GEOMETRIC_END,
- ANDROID_JPEG_QUALITY = ANDROID_JPEG_START,
- ANDROID_JPEG_THUMBNAIL_SIZE,
- ANDROID_JPEG_THUMBNAIL_QUALITY,
- ANDROID_JPEG_GPS_COORDINATES,
+ ANDROID_HOT_PIXEL_MODE = ANDROID_HOT_PIXEL_START,
+ ANDROID_HOT_PIXEL_END,
+
+ ANDROID_HOT_PIXEL_INFO_MAP = ANDROID_HOT_PIXEL_INFO_START,
+ ANDROID_HOT_PIXEL_INFO_END,
+
+ ANDROID_JPEG_GPS_COORDINATES = ANDROID_JPEG_START,
ANDROID_JPEG_GPS_PROCESSING_METHOD,
ANDROID_JPEG_GPS_TIMESTAMP,
ANDROID_JPEG_ORIENTATION,
+ ANDROID_JPEG_QUALITY,
+ ANDROID_JPEG_THUMBNAIL_QUALITY,
+ ANDROID_JPEG_THUMBNAIL_SIZE,
+ ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES,
+ ANDROID_JPEG_MAX_SIZE,
ANDROID_JPEG_SIZE,
ANDROID_JPEG_END,
- ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES = ANDROID_JPEG_INFO_START,
- ANDROID_JPEG_MAX_SIZE,
- ANDROID_JPEG_INFO_END,
+ ANDROID_LENS_APERTURE = ANDROID_LENS_START,
+ ANDROID_LENS_FILTER_DENSITY,
+ ANDROID_LENS_FOCAL_LENGTH,
+ ANDROID_LENS_FOCUS_DISTANCE,
+ ANDROID_LENS_OPTICAL_STABILIZATION_MODE,
+ ANDROID_LENS_FACING,
+ ANDROID_LENS_OPTICAL_AXIS_ANGLE,
+ ANDROID_LENS_POSITION,
+ ANDROID_LENS_FOCUS_RANGE,
+ ANDROID_LENS_STATE,
+ ANDROID_LENS_END,
- ANDROID_STATS_FACE_DETECT_MODE = ANDROID_STATS_START,
- ANDROID_STATS_FACE_RECTANGLES,
- ANDROID_STATS_FACE_SCORES,
- ANDROID_STATS_FACE_LANDMARKS,
- ANDROID_STATS_FACE_IDS,
- ANDROID_STATS_HISTOGRAM_MODE,
- ANDROID_STATS_HISTOGRAM,
- ANDROID_STATS_SHARPNESS_MAP_MODE,
- ANDROID_STATS_SHARPNESS_MAP,
- ANDROID_STATS_END,
+ ANDROID_LENS_INFO_AVAILABLE_APERTURES
+ = ANDROID_LENS_INFO_START,
+ ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES,
+ ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS,
+ ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION,
+ ANDROID_LENS_INFO_GEOMETRIC_CORRECTION_MAP,
+ ANDROID_LENS_INFO_GEOMETRIC_CORRECTION_MAP_SIZE,
+ ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE,
+ ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE,
+ ANDROID_LENS_INFO_SHADING_MAP,
+ ANDROID_LENS_INFO_SHADING_MAP_SIZE,
+ ANDROID_LENS_INFO_END,
- ANDROID_STATS_AVAILABLE_FACE_DETECT_MODES = ANDROID_STATS_INFO_START,
- ANDROID_STATS_MAX_FACE_COUNT,
- ANDROID_STATS_HISTOGRAM_BUCKET_COUNT,
- ANDROID_STATS_MAX_HISTOGRAM_COUNT,
- ANDROID_STATS_SHARPNESS_MAP_SIZE,
- ANDROID_STATS_MAX_SHARPNESS_MAP_VALUE,
- ANDROID_STATS_INFO_END,
+ ANDROID_NOISE_REDUCTION_MODE = ANDROID_NOISE_REDUCTION_START,
+ ANDROID_NOISE_REDUCTION_STRENGTH,
+ ANDROID_NOISE_REDUCTION_END,
- ANDROID_CONTROL_CAPTURE_INTENT = ANDROID_CONTROL_START,
- ANDROID_CONTROL_MODE,
- ANDROID_CONTROL_EFFECT_MODE,
- ANDROID_CONTROL_SCENE_MODE,
- ANDROID_CONTROL_VIDEO_STABILIZATION_MODE,
- ANDROID_CONTROL_AE_MODE,
- ANDROID_CONTROL_AE_LOCK,
- ANDROID_CONTROL_AE_REGIONS,
- ANDROID_CONTROL_AE_EXP_COMPENSATION,
- ANDROID_CONTROL_AE_TARGET_FPS_RANGE,
- ANDROID_CONTROL_AE_ANTIBANDING_MODE,
- ANDROID_CONTROL_AE_STATE,
- ANDROID_CONTROL_AE_PRECAPTURE_ID,
- ANDROID_CONTROL_AWB_MODE,
- ANDROID_CONTROL_AWB_LOCK,
- ANDROID_CONTROL_AWB_REGIONS,
- ANDROID_CONTROL_AWB_STATE,
- ANDROID_CONTROL_AF_MODE,
- ANDROID_CONTROL_AF_REGIONS,
- ANDROID_CONTROL_AF_STATE,
- ANDROID_CONTROL_AF_TRIGGER_ID,
- ANDROID_CONTROL_END,
-
- ANDROID_CONTROL_AVAILABLE_SCENE_MODES = ANDROID_CONTROL_INFO_START,
- ANDROID_CONTROL_AVAILABLE_EFFECTS,
- ANDROID_CONTROL_MAX_REGIONS,
- ANDROID_CONTROL_AE_AVAILABLE_MODES,
- ANDROID_CONTROL_AE_EXP_COMPENSATION_STEP,
- ANDROID_CONTROL_AE_EXP_COMPENSATION_RANGE,
- ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
- ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES,
- ANDROID_CONTROL_AWB_AVAILABLE_MODES,
- ANDROID_CONTROL_AF_AVAILABLE_MODES,
- ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES,
- ANDROID_CONTROL_SCENE_MODE_OVERRIDES,
- ANDROID_CONTROL_INFO_END,
-
- ANDROID_QUIRKS_TRIGGER_AF_WITH_AUTO = ANDROID_QUIRKS_INFO_START,
+ ANDROID_QUIRKS_METERING_CROP_REGION
+ = ANDROID_QUIRKS_START,
+ ANDROID_QUIRKS_TRIGGER_AF_WITH_AUTO,
ANDROID_QUIRKS_USE_ZSL_FORMAT,
- ANDROID_QUIRKS_METERING_CROP_REGION,
- ANDROID_QUIRKS_INFO_END
-};
+ ANDROID_QUIRKS_END,
+
+ ANDROID_REQUEST_FRAME_COUNT = ANDROID_REQUEST_START,
+ ANDROID_REQUEST_ID,
+ ANDROID_REQUEST_INPUT_STREAMS,
+ ANDROID_REQUEST_METADATA_MODE,
+ ANDROID_REQUEST_OUTPUT_STREAMS,
+ ANDROID_REQUEST_TYPE,
+ ANDROID_REQUEST_MAX_NUM_OUTPUT_STREAMS,
+ ANDROID_REQUEST_MAX_NUM_REPROCESS_STREAMS,
+ ANDROID_REQUEST_END,
+
+ ANDROID_SCALER_CROP_REGION = ANDROID_SCALER_START,
+ ANDROID_SCALER_AVAILABLE_FORMATS,
+ ANDROID_SCALER_AVAILABLE_JPEG_MIN_DURATIONS,
+ ANDROID_SCALER_AVAILABLE_JPEG_SIZES,
+ ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM,
+ ANDROID_SCALER_AVAILABLE_PROCESSED_MIN_DURATIONS,
+ ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES,
+ ANDROID_SCALER_AVAILABLE_RAW_MIN_DURATIONS,
+ ANDROID_SCALER_AVAILABLE_RAW_SIZES,
+ ANDROID_SCALER_MAX_DIGITAL_ZOOM,
+ ANDROID_SCALER_END,
+
+ ANDROID_SENSOR_EXPOSURE_TIME = ANDROID_SENSOR_START,
+ ANDROID_SENSOR_FRAME_DURATION,
+ ANDROID_SENSOR_SENSITIVITY,
+ ANDROID_SENSOR_BASE_GAIN_FACTOR,
+ ANDROID_SENSOR_BLACK_LEVEL_PATTERN,
+ ANDROID_SENSOR_CALIBRATION_TRANSFORM1,
+ ANDROID_SENSOR_CALIBRATION_TRANSFORM2,
+ ANDROID_SENSOR_COLOR_TRANSFORM1,
+ ANDROID_SENSOR_COLOR_TRANSFORM2,
+ ANDROID_SENSOR_FORWARD_MATRIX1,
+ ANDROID_SENSOR_FORWARD_MATRIX2,
+ ANDROID_SENSOR_MAX_ANALOG_SENSITIVITY,
+ ANDROID_SENSOR_NOISE_MODEL_COEFFICIENTS,
+ ANDROID_SENSOR_ORIENTATION,
+ ANDROID_SENSOR_REFERENCE_ILLUMINANT1,
+ ANDROID_SENSOR_REFERENCE_ILLUMINANT2,
+ ANDROID_SENSOR_TIMESTAMP,
+ ANDROID_SENSOR_END,
+
+ ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE
+ = ANDROID_SENSOR_INFO_START,
+ ANDROID_SENSOR_INFO_AVAILABLE_SENSITIVITIES,
+ ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT,
+ ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE,
+ ANDROID_SENSOR_INFO_MAX_FRAME_DURATION,
+ ANDROID_SENSOR_INFO_PHYSICAL_SIZE,
+ ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE,
+ ANDROID_SENSOR_INFO_WHITE_LEVEL,
+ ANDROID_SENSOR_INFO_END,
+
+ ANDROID_SHADING_MODE = ANDROID_SHADING_START,
+ ANDROID_SHADING_STRENGTH,
+ ANDROID_SHADING_END,
+
+ ANDROID_STATISTICS_FACE_DETECT_MODE
+ = ANDROID_STATISTICS_START,
+ ANDROID_STATISTICS_HISTOGRAM_MODE,
+ ANDROID_STATISTICS_SHARPNESS_MAP_MODE,
+ ANDROID_STATISTICS_FACE_IDS,
+ ANDROID_STATISTICS_FACE_LANDMARKS,
+ ANDROID_STATISTICS_FACE_RECTANGLES,
+ ANDROID_STATISTICS_FACE_SCORES,
+ ANDROID_STATISTICS_HISTOGRAM,
+ ANDROID_STATISTICS_SHARPNESS_MAP,
+ ANDROID_STATISTICS_END,
+
+ ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES
+ = ANDROID_STATISTICS_INFO_START,
+ ANDROID_STATISTICS_INFO_HISTOGRAM_BUCKET_COUNT,
+ ANDROID_STATISTICS_INFO_MAX_FACE_COUNT,
+ ANDROID_STATISTICS_INFO_MAX_HISTOGRAM_COUNT,
+ ANDROID_STATISTICS_INFO_MAX_SHARPNESS_MAP_VALUE,
+ ANDROID_STATISTICS_INFO_SHARPNESS_MAP_SIZE,
+ ANDROID_STATISTICS_INFO_END,
+
+ ANDROID_TONEMAP_CURVE_BLUE = ANDROID_TONEMAP_START,
+ ANDROID_TONEMAP_CURVE_GREEN,
+ ANDROID_TONEMAP_CURVE_RED,
+ ANDROID_TONEMAP_MODE,
+ ANDROID_TONEMAP_MAX_CURVE_POINTS,
+ ANDROID_TONEMAP_END,
+
+} camera_metadata_tag_t;
/**
* Enumeration definitions for the various entries that need them
*/
-// ANDROID_REQUEST_METADATA_TYPE
-enum {
- ANDROID_REQUEST_TYPE_CAPTURE = 0,
- ANDROID_REQUEST_TYPE_REPROCESS
-};
+// ANDROID_COLOR_CORRECTION_MODE
+typedef enum camera_metadata_enum_android_color_correction_mode {
+ ANDROID_COLOR_CORRECTION_MODE_TRANSFORM_MATRIX,
+ ANDROID_COLOR_CORRECTION_MODE_FAST,
+ ANDROID_COLOR_CORRECTION_MODE_HIGH_QUALITY,
+} camera_metadata_enum_android_color_correction_mode_t;
-// ANDROID_REQUEST_METADATA_MODE
-enum {
- ANDROID_REQUEST_METADATA_NONE = 0,
- ANDROID_REQUEST_METADATA_FULL
-};
-// ANDROID_LENS_OPTICAL_STABILIZATION_MODE
-enum {
- ANDROID_LENS_OPTICAL_STABILIZATION_OFF = 0,
- ANDROID_LENS_OPTICAL_STABILIZATION_ON
-};
+// ANDROID_CONTROL_AE_ANTIBANDING_MODE
+typedef enum camera_metadata_enum_android_control_ae_antibanding_mode {
+ ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF,
+ ANDROID_CONTROL_AE_ANTIBANDING_MODE_50HZ,
+ ANDROID_CONTROL_AE_ANTIBANDING_MODE_60HZ,
+ ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO,
+} camera_metadata_enum_android_control_ae_antibanding_mode_t;
-// ANDROID_LENS_FACING
-enum {
- ANDROID_LENS_FACING_BACK = 0,
- ANDROID_LENS_FACING_FRONT
-};
+// ANDROID_CONTROL_AE_LOCK
+typedef enum camera_metadata_enum_android_control_ae_lock {
+ ANDROID_CONTROL_AE_LOCK_OFF,
+ ANDROID_CONTROL_AE_LOCK_ON,
+} camera_metadata_enum_android_control_ae_lock_t;
-// ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT
-enum {
- ANDROID_SENSOR_RGGB = 0,
- ANDROID_SENSOR_GRBG,
- ANDROID_SENSOR_GBRG,
- ANDROID_SENSOR_BGGR,
- ANDROID_SENSOR_RGB
-};
+// ANDROID_CONTROL_AE_MODE
+typedef enum camera_metadata_enum_android_control_ae_mode {
+ ANDROID_CONTROL_AE_MODE_OFF,
+ ANDROID_CONTROL_AE_MODE_ON,
+ ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH,
+ ANDROID_CONTROL_AE_MODE_ON_ALWAYS_FLASH,
+ ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE,
+} camera_metadata_enum_android_control_ae_mode_t;
-// ANDROID_FLASH_MODE
-enum {
- ANDROID_FLASH_OFF = 0,
- ANDROID_FLASH_SINGLE,
- ANDROID_FLASH_TORCH
-};
+// ANDROID_CONTROL_AF_MODE
+typedef enum camera_metadata_enum_android_control_af_mode {
+ ANDROID_CONTROL_AF_MODE_OFF,
+ ANDROID_CONTROL_AF_MODE_AUTO,
+ ANDROID_CONTROL_AF_MODE_MACRO,
+ ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO,
+ ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE,
+ ANDROID_CONTROL_AF_MODE_EDOF,
+} camera_metadata_enum_android_control_af_mode_t;
-// General processing block modes
-enum {
- ANDROID_PROCESSING_OFF = 0,
- ANDROID_PROCESSING_FAST,
- ANDROID_PROCESSING_HIGH_QUALITY
-};
+// ANDROID_CONTROL_AWB_LOCK
+typedef enum camera_metadata_enum_android_control_awb_lock {
+ ANDROID_CONTROL_AWB_LOCK_OFF,
+ ANDROID_CONTROL_AWB_LOCK_ON,
+} camera_metadata_enum_android_control_awb_lock_t;
-// ANDROID_DEMOSAIC_MODE
-enum {
- ANDROID_DEMOSAIC_FAST = 1,
- ANDROID_DEMOSAIC_HIGH_QUALITY
-};
-
-// ANDROID_COLOR_MODE
-enum {
- ANDROID_COLOR_FAST = 1,
- ANDROID_COLOR_HIGH_QUALITY,
- ANDROID_COLOR_TRANSFORM_MATRIX
-};
-
-// ANDROID_TONEMAP_MODE
-enum {
- ANDROID_TONEMAP_FAST = 1,
- ANDROID_TONEMAP_HIGH_QUALITY,
- ANDROID_TONEMAP_CONTRAST_CURVE
-};
-
-// ANDROID_SCALER_AVAILABLE_FORMATS uses HAL_PIXEL_FORMAT_* from
-// system/graphics.h
-
-// ANDROID_STATS_FACE_DETECTION_MODE
-enum {
- ANDROID_STATS_FACE_DETECTION_OFF = 0,
- ANDROID_STATS_FACE_DETECTION_SIMPLE,
- ANDROID_STATS_FACE_DETECTION_FULL
-};
-
-// ANDROID_STATS_HISTOGRAM/SHARPNESS_MAP_MODE
-enum {
- ANDROID_STATS_OFF = 0,
- ANDROID_STATS_ON
-};
+// ANDROID_CONTROL_AWB_MODE
+typedef enum camera_metadata_enum_android_control_awb_mode {
+ ANDROID_CONTROL_AWB_MODE_OFF,
+ ANDROID_CONTROL_AWB_MODE_AUTO,
+ ANDROID_CONTROL_AWB_MODE_INCANDESCENT,
+ ANDROID_CONTROL_AWB_MODE_FLUORESCENT,
+ ANDROID_CONTROL_AWB_MODE_WARM_FLUORESCENT,
+ ANDROID_CONTROL_AWB_MODE_DAYLIGHT,
+ ANDROID_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT,
+ ANDROID_CONTROL_AWB_MODE_TWILIGHT,
+ ANDROID_CONTROL_AWB_MODE_SHADE,
+} camera_metadata_enum_android_control_awb_mode_t;
// ANDROID_CONTROL_CAPTURE_INTENT
-enum {
- ANDROID_CONTROL_INTENT_CUSTOM = 0,
- ANDROID_CONTROL_INTENT_PREVIEW,
- ANDROID_CONTROL_INTENT_STILL_CAPTURE,
- ANDROID_CONTROL_INTENT_VIDEO_RECORD,
- ANDROID_CONTROL_INTENT_VIDEO_SNAPSHOT,
- ANDROID_CONTROL_INTENT_ZERO_SHUTTER_LAG
-};
+typedef enum camera_metadata_enum_android_control_capture_intent {
+ ANDROID_CONTROL_CAPTURE_INTENT_CUSTOM,
+ ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW,
+ ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE,
+ ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_RECORD,
+ ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT,
+ ANDROID_CONTROL_CAPTURE_INTENT_ZERO_SHUTTER_LAG,
+} camera_metadata_enum_android_control_capture_intent_t;
+
+// ANDROID_CONTROL_EFFECT_MODE
+typedef enum camera_metadata_enum_android_control_effect_mode {
+ ANDROID_CONTROL_EFFECT_MODE_OFF,
+ ANDROID_CONTROL_EFFECT_MODE_MONO,
+ ANDROID_CONTROL_EFFECT_MODE_NEGATIVE,
+ ANDROID_CONTROL_EFFECT_MODE_SOLARIZE,
+ ANDROID_CONTROL_EFFECT_MODE_SEPIA,
+ ANDROID_CONTROL_EFFECT_MODE_POSTERIZE,
+ ANDROID_CONTROL_EFFECT_MODE_WHITEBOARD,
+ ANDROID_CONTROL_EFFECT_MODE_BLACKBOARD,
+ ANDROID_CONTROL_EFFECT_MODE_AQUA,
+} camera_metadata_enum_android_control_effect_mode_t;
// ANDROID_CONTROL_MODE
-enum {
- ANDROID_CONTROL_OFF = 0,
- ANDROID_CONTROL_AUTO,
- ANDROID_CONTROL_USE_SCENE_MODE
-};
+typedef enum camera_metadata_enum_android_control_mode {
+ ANDROID_CONTROL_MODE_OFF,
+ ANDROID_CONTROL_MODE_AUTO,
+ ANDROID_CONTROL_MODE_USE_SCENE_MODE,
+} camera_metadata_enum_android_control_mode_t;
// ANDROID_CONTROL_SCENE_MODE
-enum {
- ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED = 0, // Only for availableSceneModes
+typedef enum camera_metadata_enum_android_control_scene_mode {
+ ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED = 0,
ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY,
ANDROID_CONTROL_SCENE_MODE_ACTION,
ANDROID_CONTROL_SCENE_MODE_PORTRAIT,
@@ -439,104 +413,217 @@
ANDROID_CONTROL_SCENE_MODE_SPORTS,
ANDROID_CONTROL_SCENE_MODE_PARTY,
ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT,
- ANDROID_CONTROL_SCENE_MODE_BARCODE
-};
+ ANDROID_CONTROL_SCENE_MODE_BARCODE,
+} camera_metadata_enum_android_control_scene_mode_t;
-// ANDROID_CONTROL_EFFECT_MODE
-enum {
- ANDROID_CONTROL_EFFECT_OFF = 0,
- ANDROID_CONTROL_EFFECT_MONO,
- ANDROID_CONTROL_EFFECT_NEGATIVE,
- ANDROID_CONTROL_EFFECT_SOLARIZE,
- ANDROID_CONTROL_EFFECT_SEPIA,
- ANDROID_CONTROL_EFFECT_POSTERIZE,
- ANDROID_CONTROL_EFFECT_WHITEBOARD,
- ANDROID_CONTROL_EFFECT_BLACKBOARD,
- ANDROID_CONTROL_EFFECT_AQUA
-};
-
-// ANDROID_CONTROL_AE_MODE
-enum {
- ANDROID_CONTROL_AE_OFF = 0,
- ANDROID_CONTROL_AE_ON,
- ANDROID_CONTROL_AE_ON_AUTO_FLASH,
- ANDROID_CONTROL_AE_ON_ALWAYS_FLASH,
- ANDROID_CONTROL_AE_ON_AUTO_FLASH_REDEYE
-};
-
-// ANDROID_CONTROL_AE_LOCK
-enum {
- ANDROID_CONTROL_AE_LOCK_OFF = 0,
- ANDROID_CONTROL_AE_LOCK_ON
-};
-
-// ANDROID_CONTROL_AE_ANTIBANDING_MODE
-enum {
- ANDROID_CONTROL_AE_ANTIBANDING_OFF = 0,
- ANDROID_CONTROL_AE_ANTIBANDING_50HZ,
- ANDROID_CONTROL_AE_ANTIBANDING_60HZ,
- ANDROID_CONTROL_AE_ANTIBANDING_AUTO
-};
+// ANDROID_CONTROL_VIDEO_STABILIZATION_MODE
+typedef enum camera_metadata_enum_android_control_video_stabilization_mode {
+ ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF,
+ ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_ON,
+} camera_metadata_enum_android_control_video_stabilization_mode_t;
// ANDROID_CONTROL_AE_STATE
-enum {
- ANDROID_CONTROL_AE_STATE_INACTIVE = 0,
+typedef enum camera_metadata_enum_android_control_ae_state {
+ ANDROID_CONTROL_AE_STATE_INACTIVE,
ANDROID_CONTROL_AE_STATE_SEARCHING,
ANDROID_CONTROL_AE_STATE_CONVERGED,
ANDROID_CONTROL_AE_STATE_LOCKED,
ANDROID_CONTROL_AE_STATE_FLASH_REQUIRED,
- ANDROID_CONTROL_AE_STATE_PRECAPTURE
-};
-
-// ANDROID_CONTROL_AWB_MODE
-enum {
- ANDROID_CONTROL_AWB_OFF = 0,
- ANDROID_CONTROL_AWB_AUTO,
- ANDROID_CONTROL_AWB_INCANDESCENT,
- ANDROID_CONTROL_AWB_FLUORESCENT,
- ANDROID_CONTROL_AWB_WARM_FLUORESCENT,
- ANDROID_CONTROL_AWB_DAYLIGHT,
- ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT,
- ANDROID_CONTROL_AWB_TWILIGHT,
- ANDROID_CONTROL_AWB_SHADE
-};
-
-// ANDROID_CONTROL_AWB_LOCK
-enum {
- ANDROID_CONTROL_AWB_LOCK_OFF = 0,
- ANDROID_CONTROL_AWB_LOCK_ON
-};
-
-// ANDROID_CONTROL_AWB_STATE
-enum {
- ANDROID_CONTROL_AWB_STATE_INACTIVE = 0,
- ANDROID_CONTROL_AWB_STATE_SEARCHING,
- ANDROID_CONTROL_AWB_STATE_CONVERGED,
- ANDROID_CONTROL_AWB_STATE_LOCKED,
-};
-
-// ANDROID_CONTROL_AF_MODE
-enum {
- ANDROID_CONTROL_AF_OFF = 0,
- ANDROID_CONTROL_AF_AUTO,
- ANDROID_CONTROL_AF_MACRO,
- ANDROID_CONTROL_AF_CONTINUOUS_VIDEO,
- ANDROID_CONTROL_AF_CONTINUOUS_PICTURE,
- ANDROID_CONTROL_AF_EDOF
-};
+ ANDROID_CONTROL_AE_STATE_PRECAPTURE,
+} camera_metadata_enum_android_control_ae_state_t;
// ANDROID_CONTROL_AF_STATE
-enum {
- ANDROID_CONTROL_AF_STATE_INACTIVE = 0,
+typedef enum camera_metadata_enum_android_control_af_state {
+ ANDROID_CONTROL_AF_STATE_INACTIVE,
ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN,
ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED,
ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN,
ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED,
- ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED
-};
+ ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED,
+} camera_metadata_enum_android_control_af_state_t;
-// ANDROID_CONTROL_VIDEO_STABILIZATION
-enum {
- ANDROID_CONTROL_VIDEO_STABILIZATION_OFF = 0,
- ANDROID_CONTROL_VIDEO_STABILIZATION_ON
-};
+// ANDROID_CONTROL_AWB_STATE
+typedef enum camera_metadata_enum_android_control_awb_state {
+ ANDROID_CONTROL_AWB_STATE_INACTIVE,
+ ANDROID_CONTROL_AWB_STATE_SEARCHING,
+ ANDROID_CONTROL_AWB_STATE_CONVERGED,
+ ANDROID_CONTROL_AWB_STATE_LOCKED,
+} camera_metadata_enum_android_control_awb_state_t;
+
+
+// ANDROID_DEMOSAIC_MODE
+typedef enum camera_metadata_enum_android_demosaic_mode {
+ ANDROID_DEMOSAIC_MODE_FAST,
+ ANDROID_DEMOSAIC_MODE_HIGH_QUALITY,
+} camera_metadata_enum_android_demosaic_mode_t;
+
+
+// ANDROID_EDGE_MODE
+typedef enum camera_metadata_enum_android_edge_mode {
+ ANDROID_EDGE_MODE_OFF,
+ ANDROID_EDGE_MODE_FAST,
+ ANDROID_EDGE_MODE_HIGH_QUALITY,
+} camera_metadata_enum_android_edge_mode_t;
+
+
+// ANDROID_FLASH_MODE
+typedef enum camera_metadata_enum_android_flash_mode {
+ ANDROID_FLASH_MODE_OFF,
+ ANDROID_FLASH_MODE_SINGLE,
+ ANDROID_FLASH_MODE_TORCH,
+} camera_metadata_enum_android_flash_mode_t;
+
+// ANDROID_FLASH_STATE
+typedef enum camera_metadata_enum_android_flash_state {
+ ANDROID_FLASH_STATE_UNAVAILABLE,
+ ANDROID_FLASH_STATE_CHARGING,
+ ANDROID_FLASH_STATE_READY,
+ ANDROID_FLASH_STATE_FIRED,
+} camera_metadata_enum_android_flash_state_t;
+
+
+
+// ANDROID_GEOMETRIC_MODE
+typedef enum camera_metadata_enum_android_geometric_mode {
+ ANDROID_GEOMETRIC_MODE_OFF,
+ ANDROID_GEOMETRIC_MODE_FAST,
+ ANDROID_GEOMETRIC_MODE_HIGH_QUALITY,
+} camera_metadata_enum_android_geometric_mode_t;
+
+
+// ANDROID_HOT_PIXEL_MODE
+typedef enum camera_metadata_enum_android_hot_pixel_mode {
+ ANDROID_HOT_PIXEL_MODE_OFF,
+ ANDROID_HOT_PIXEL_MODE_FAST,
+ ANDROID_HOT_PIXEL_MODE_HIGH_QUALITY,
+} camera_metadata_enum_android_hot_pixel_mode_t;
+
+
+
+
+// ANDROID_LENS_OPTICAL_STABILIZATION_MODE
+typedef enum camera_metadata_enum_android_lens_optical_stabilization_mode {
+ ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF,
+ ANDROID_LENS_OPTICAL_STABILIZATION_MODE_ON,
+} camera_metadata_enum_android_lens_optical_stabilization_mode_t;
+
+// ANDROID_LENS_FACING
+typedef enum camera_metadata_enum_android_lens_facing {
+ ANDROID_LENS_FACING_FRONT,
+ ANDROID_LENS_FACING_BACK,
+} camera_metadata_enum_android_lens_facing_t;
+
+// ANDROID_LENS_STATE
+typedef enum camera_metadata_enum_android_lens_state {
+ ANDROID_LENS_STATE_STATIONARY,
+} camera_metadata_enum_android_lens_state_t;
+
+
+
+// ANDROID_NOISE_REDUCTION_MODE
+typedef enum camera_metadata_enum_android_noise_reduction_mode {
+ ANDROID_NOISE_REDUCTION_MODE_OFF,
+ ANDROID_NOISE_REDUCTION_MODE_FAST,
+ ANDROID_NOISE_REDUCTION_MODE_HIGH_QUALITY,
+} camera_metadata_enum_android_noise_reduction_mode_t;
+
+
+
+// ANDROID_REQUEST_METADATA_MODE
+typedef enum camera_metadata_enum_android_request_metadata_mode {
+ ANDROID_REQUEST_METADATA_MODE_NONE,
+ ANDROID_REQUEST_METADATA_MODE_FULL,
+} camera_metadata_enum_android_request_metadata_mode_t;
+
+// ANDROID_REQUEST_TYPE
+typedef enum camera_metadata_enum_android_request_type {
+ ANDROID_REQUEST_TYPE_CAPTURE,
+ ANDROID_REQUEST_TYPE_REPROCESS,
+} camera_metadata_enum_android_request_type_t;
+
+
+// ANDROID_SCALER_AVAILABLE_FORMATS
+typedef enum camera_metadata_enum_android_scaler_available_formats {
+ ANDROID_SCALER_AVAILABLE_FORMATS_RAW_SENSOR = 0x20,
+ ANDROID_SCALER_AVAILABLE_FORMATS_YV12 = 0x32315659,
+ ANDROID_SCALER_AVAILABLE_FORMATS_YCbCr_420_SP = 0x11,
+ ANDROID_SCALER_AVAILABLE_FORMATS_JPEG = 0x21,
+} camera_metadata_enum_android_scaler_available_formats_t;
+
+
+// ANDROID_SENSOR_REFERENCE_ILLUMINANT1
+typedef enum camera_metadata_enum_android_sensor_reference_illuminant1 {
+ ANDROID_SENSOR_REFERENCE_ILLUMINANT1_DAYLIGHT = 1,
+ ANDROID_SENSOR_REFERENCE_ILLUMINANT1_FLUORESCENT = 2,
+ ANDROID_SENSOR_REFERENCE_ILLUMINANT1_TUNGSTEN = 3,
+ ANDROID_SENSOR_REFERENCE_ILLUMINANT1_FLASH = 4,
+ ANDROID_SENSOR_REFERENCE_ILLUMINANT1_FINE_WEATHER = 9,
+ ANDROID_SENSOR_REFERENCE_ILLUMINANT1_CLOUDY_WEATHER = 10,
+ ANDROID_SENSOR_REFERENCE_ILLUMINANT1_SHADE = 11,
+ ANDROID_SENSOR_REFERENCE_ILLUMINANT1_DAYLIGHT_FLUORESCENT = 12,
+ ANDROID_SENSOR_REFERENCE_ILLUMINANT1_DAY_WHITE_FLUORESCENT = 13,
+ ANDROID_SENSOR_REFERENCE_ILLUMINANT1_COOL_WHITE_FLUORESCENT = 14,
+ ANDROID_SENSOR_REFERENCE_ILLUMINANT1_WHITE_FLUORESCENT = 15,
+ ANDROID_SENSOR_REFERENCE_ILLUMINANT1_STANDARD_A = 17,
+ ANDROID_SENSOR_REFERENCE_ILLUMINANT1_STANDARD_B = 18,
+ ANDROID_SENSOR_REFERENCE_ILLUMINANT1_STANDARD_C = 19,
+ ANDROID_SENSOR_REFERENCE_ILLUMINANT1_D55 = 20,
+ ANDROID_SENSOR_REFERENCE_ILLUMINANT1_D65 = 21,
+ ANDROID_SENSOR_REFERENCE_ILLUMINANT1_D75 = 22,
+ ANDROID_SENSOR_REFERENCE_ILLUMINANT1_D50 = 23,
+ ANDROID_SENSOR_REFERENCE_ILLUMINANT1_ISO_STUDIO_TUNGSTEN = 24,
+} camera_metadata_enum_android_sensor_reference_illuminant1_t;
+
+
+// ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT
+typedef enum camera_metadata_enum_android_sensor_info_color_filter_arrangement {
+ ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_RGGB,
+ ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_GRBG,
+ ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_GBRG,
+ ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_BGGR,
+ ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_RGB,
+} camera_metadata_enum_android_sensor_info_color_filter_arrangement_t;
+
+
+// ANDROID_SHADING_MODE
+typedef enum camera_metadata_enum_android_shading_mode {
+ ANDROID_SHADING_MODE_OFF,
+ ANDROID_SHADING_MODE_FAST,
+ ANDROID_SHADING_MODE_HIGH_QUALITY,
+} camera_metadata_enum_android_shading_mode_t;
+
+
+// ANDROID_STATISTICS_FACE_DETECT_MODE
+typedef enum camera_metadata_enum_android_statistics_face_detect_mode {
+ ANDROID_STATISTICS_FACE_DETECT_MODE_OFF,
+ ANDROID_STATISTICS_FACE_DETECT_MODE_SIMPLE,
+ ANDROID_STATISTICS_FACE_DETECT_MODE_FULL,
+} camera_metadata_enum_android_statistics_face_detect_mode_t;
+
+// ANDROID_STATISTICS_HISTOGRAM_MODE
+typedef enum camera_metadata_enum_android_statistics_histogram_mode {
+ ANDROID_STATISTICS_HISTOGRAM_MODE_OFF,
+ ANDROID_STATISTICS_HISTOGRAM_MODE_ON,
+} camera_metadata_enum_android_statistics_histogram_mode_t;
+
+// ANDROID_STATISTICS_SHARPNESS_MAP_MODE
+typedef enum camera_metadata_enum_android_statistics_sharpness_map_mode {
+ ANDROID_STATISTICS_SHARPNESS_MAP_MODE_OFF,
+ ANDROID_STATISTICS_SHARPNESS_MAP_MODE_ON,
+} camera_metadata_enum_android_statistics_sharpness_map_mode_t;
+
+
+
+// ANDROID_TONEMAP_MODE
+typedef enum camera_metadata_enum_android_tonemap_mode {
+ ANDROID_TONEMAP_MODE_CONTRAST_CURVE,
+ ANDROID_TONEMAP_MODE_FAST,
+ ANDROID_TONEMAP_MODE_HIGH_QUALITY,
+} camera_metadata_enum_android_tonemap_mode_t;
+
+
+
+int camera_metadata_enum_snprint(uint32_t tag,
+ uint32_t value,
+ char *dst,
+ size_t size);
diff --git a/camera/src/camera_metadata.c b/camera/src/camera_metadata.c
index e5c2f25..1963b89 100644
--- a/camera/src/camera_metadata.c
+++ b/camera/src/camera_metadata.c
@@ -640,7 +640,8 @@
return OK;
}
-static void print_data(int fd, const uint8_t *data_ptr, int type, int count,
+static void print_data(int fd, const uint8_t *data_ptr, uint32_t tag, int type,
+ int count,
int indentation);
void dump_camera_metadata(const camera_metadata_t *metadata,
@@ -714,11 +715,11 @@
int count = entry->count;
if (verbosity < 2 && count > 16) count = 16;
- print_data(fd, data_ptr, entry->type, count, indentation);
+ print_data(fd, data_ptr, entry->tag, entry->type, count, indentation);
}
}
-static void print_data(int fd, const uint8_t *data_ptr,
+static void print_data(int fd, const uint8_t *data_ptr, uint32_t tag,
int type, int count, int indentation) {
static int values_per_line[NUM_TYPES] = {
[TYPE_BYTE] = 16,
@@ -729,6 +730,8 @@
[TYPE_RATIONAL] = 2,
};
size_t type_size = camera_metadata_type_size[type];
+ char value_string_tmp[CAMERA_METADATA_ENUM_STRING_MAX_SIZE];
+ uint32_t value;
int lines = count / values_per_line[type];
if (count % values_per_line[type] != 0) lines++;
@@ -743,12 +746,31 @@
switch (type) {
case TYPE_BYTE:
- fdprintf(fd, "%hhu ",
- *(data_ptr + index));
+ value = *(data_ptr + index);
+ if (camera_metadata_enum_snprint(tag,
+ value,
+ value_string_tmp,
+ sizeof(value_string_tmp))
+ == OK) {
+ fdprintf(fd, "%s ", value_string_tmp);
+ } else {
+ fdprintf(fd, "%hhu ",
+ *(data_ptr + index));
+ }
break;
case TYPE_INT32:
- fdprintf(fd, "%d ",
- *(int32_t*)(data_ptr + index));
+ value =
+ *(int32_t*)(data_ptr + index);
+ if (camera_metadata_enum_snprint(tag,
+ value,
+ value_string_tmp,
+ sizeof(value_string_tmp))
+ == OK) {
+ fdprintf(fd, "%s ", value_string_tmp);
+ } else {
+ fdprintf(fd, "%d ",
+ *(int32_t*)(data_ptr + index));
+ }
break;
case TYPE_FLOAT:
fdprintf(fd, "%0.2f ",
diff --git a/camera/src/camera_metadata_tag_info.c b/camera/src/camera_metadata_tag_info.c
index 2b723c9..e8d340a 100644
--- a/camera/src/camera_metadata_tag_info.c
+++ b/camera/src/camera_metadata_tag_info.c
@@ -24,549 +24,1755 @@
* sync with camera_metadata_tags.h
*/
+/**
+ * ! Do not edit this file directly !
+ *
+ * Generated automatically from camera_metadata_tag_info.mako
+ */
+
const char *camera_metadata_section_names[ANDROID_SECTION_COUNT] = {
- [ANDROID_REQUEST] = "android.request",
- [ANDROID_LENS] = "android.lens",
- [ANDROID_LENS_INFO] = "android.lens.info",
- [ANDROID_SENSOR] = "android.sensor",
- [ANDROID_SENSOR_INFO] = "android.sensor.info",
- [ANDROID_FLASH] = "android.flash",
- [ANDROID_FLASH_INFO] = "android.flash.info",
- [ANDROID_HOT_PIXEL] = "android.hotPixel",
- [ANDROID_HOT_PIXEL_INFO] = "android.hotPixel.info",
- [ANDROID_DEMOSAIC] = "android.demosaic",
- [ANDROID_DEMOSAIC_INFO] = "android.demosaic.info",
- [ANDROID_NOISE] = "android.noiseReduction",
- [ANDROID_NOISE_INFO] = "android.noiseReduction.info",
- [ANDROID_SHADING] = "android.shadingCorrection",
- [ANDROID_SHADING_INFO] = "android.shadingCorrection.info",
- [ANDROID_GEOMETRIC] = "android.geometricCorrection",
- [ANDROID_GEOMETRIC_INFO] = "android.geometricCorrection.info",
- [ANDROID_COLOR] = "android.colorCorrection",
- [ANDROID_COLOR_INFO] = "android.colorCorrection.info",
- [ANDROID_TONEMAP] = "android.tonemap",
- [ANDROID_TONEMAP_INFO] = "android.tonemap.info",
- [ANDROID_EDGE] = "android.edge",
- [ANDROID_EDGE_INFO] = "android.edge.info",
- [ANDROID_SCALER] = "android.scaler",
- [ANDROID_SCALER_INFO] = "android.scaler.info",
- [ANDROID_JPEG] = "android.jpeg",
- [ANDROID_JPEG_INFO] = "android.jpeg.info",
- [ANDROID_STATS] = "android.statistics",
- [ANDROID_STATS_INFO] = "android.statistics.info",
- [ANDROID_CONTROL] = "android.control",
- [ANDROID_CONTROL_INFO] = "android.control.info",
- [ANDROID_QUIRKS_INFO] = "android.quirks.info"
+ [ANDROID_COLOR_CORRECTION] = "android.colorCorrection",
+ [ANDROID_CONTROL] = "android.control",
+ [ANDROID_DEMOSAIC] = "android.demosaic",
+ [ANDROID_EDGE] = "android.edge",
+ [ANDROID_FLASH] = "android.flash",
+ [ANDROID_FLASH_INFO] = "android.flash.info",
+ [ANDROID_GEOMETRIC] = "android.geometric",
+ [ANDROID_HOT_PIXEL] = "android.hotPixel",
+ [ANDROID_HOT_PIXEL_INFO] = "android.hotPixel.info",
+ [ANDROID_JPEG] = "android.jpeg",
+ [ANDROID_LENS] = "android.lens",
+ [ANDROID_LENS_INFO] = "android.lens.info",
+ [ANDROID_NOISE_REDUCTION] = "android.noiseReduction",
+ [ANDROID_QUIRKS] = "android.quirks",
+ [ANDROID_REQUEST] = "android.request",
+ [ANDROID_SCALER] = "android.scaler",
+ [ANDROID_SENSOR] = "android.sensor",
+ [ANDROID_SENSOR_INFO] = "android.sensor.info",
+ [ANDROID_SHADING] = "android.shading",
+ [ANDROID_STATISTICS] = "android.statistics",
+ [ANDROID_STATISTICS_INFO] = "android.statistics.info",
+ [ANDROID_TONEMAP] = "android.tonemap",
};
unsigned int camera_metadata_section_bounds[ANDROID_SECTION_COUNT][2] = {
- [ANDROID_REQUEST] = { ANDROID_REQUEST_START,
- ANDROID_REQUEST_END },
- [ANDROID_LENS] = { ANDROID_LENS_START,
- ANDROID_LENS_END },
- [ANDROID_LENS_INFO] = { ANDROID_LENS_INFO_START,
- ANDROID_LENS_INFO_END },
- [ANDROID_SENSOR] = { ANDROID_SENSOR_START,
- ANDROID_SENSOR_END },
- [ANDROID_SENSOR_INFO] = { ANDROID_SENSOR_INFO_START,
- ANDROID_SENSOR_INFO_END },
- [ANDROID_FLASH] = { ANDROID_FLASH_START,
- ANDROID_FLASH_END },
- [ANDROID_FLASH_INFO] = { ANDROID_FLASH_INFO_START,
- ANDROID_FLASH_INFO_END },
- [ANDROID_HOT_PIXEL] = { ANDROID_HOT_PIXEL_START,
- ANDROID_HOT_PIXEL_END },
- [ANDROID_HOT_PIXEL_INFO] = { ANDROID_HOT_PIXEL_INFO_START,
- ANDROID_HOT_PIXEL_INFO_END },
- [ANDROID_DEMOSAIC] = { ANDROID_DEMOSAIC_START,
- ANDROID_DEMOSAIC_END },
- [ANDROID_DEMOSAIC_INFO] = { ANDROID_DEMOSAIC_INFO_START,
- ANDROID_DEMOSAIC_INFO_END },
- [ANDROID_NOISE] = { ANDROID_NOISE_START,
- ANDROID_NOISE_END },
- [ANDROID_NOISE_INFO] = { ANDROID_NOISE_INFO_START,
- ANDROID_NOISE_INFO_END },
- [ANDROID_SHADING] = { ANDROID_SHADING_START,
- ANDROID_SHADING_END },
- [ANDROID_SHADING_INFO] = { ANDROID_SHADING_INFO_START,
- ANDROID_SHADING_INFO_END },
- [ANDROID_GEOMETRIC] = { ANDROID_GEOMETRIC_START,
- ANDROID_GEOMETRIC_END },
- [ANDROID_GEOMETRIC_INFO] = { ANDROID_GEOMETRIC_INFO_START,
- ANDROID_GEOMETRIC_INFO_END },
- [ANDROID_COLOR] = { ANDROID_COLOR_START,
- ANDROID_COLOR_END },
- [ANDROID_COLOR_INFO] = { ANDROID_COLOR_INFO_START,
- ANDROID_COLOR_INFO_END },
- [ANDROID_TONEMAP] = { ANDROID_TONEMAP_START,
- ANDROID_TONEMAP_END },
- [ANDROID_TONEMAP_INFO] = { ANDROID_TONEMAP_INFO_START,
- ANDROID_TONEMAP_INFO_END },
- [ANDROID_EDGE] = { ANDROID_EDGE_START,
- ANDROID_EDGE_END },
- [ANDROID_EDGE_INFO] = { ANDROID_EDGE_INFO_START,
- ANDROID_EDGE_INFO_END },
- [ANDROID_SCALER] = { ANDROID_SCALER_START,
- ANDROID_SCALER_END },
- [ANDROID_SCALER_INFO] = { ANDROID_SCALER_INFO_START,
- ANDROID_SCALER_INFO_END },
- [ANDROID_JPEG] = { ANDROID_JPEG_START,
- ANDROID_JPEG_END },
- [ANDROID_JPEG_INFO] = { ANDROID_JPEG_INFO_START,
- ANDROID_JPEG_INFO_END },
- [ANDROID_STATS] = { ANDROID_STATS_START,
- ANDROID_STATS_END },
- [ANDROID_STATS_INFO] = { ANDROID_STATS_INFO_START,
- ANDROID_STATS_INFO_END },
- [ANDROID_CONTROL] = { ANDROID_CONTROL_START,
- ANDROID_CONTROL_END },
- [ANDROID_CONTROL_INFO] = { ANDROID_CONTROL_INFO_START,
- ANDROID_CONTROL_INFO_END },
- [ANDROID_QUIRKS_INFO] = { ANDROID_QUIRKS_INFO_START,
- ANDROID_QUIRKS_INFO_END }
+ [ANDROID_COLOR_CORRECTION] = { ANDROID_COLOR_CORRECTION_START,
+ ANDROID_COLOR_CORRECTION_END },
+ [ANDROID_CONTROL] = { ANDROID_CONTROL_START,
+ ANDROID_CONTROL_END },
+ [ANDROID_DEMOSAIC] = { ANDROID_DEMOSAIC_START,
+ ANDROID_DEMOSAIC_END },
+ [ANDROID_EDGE] = { ANDROID_EDGE_START,
+ ANDROID_EDGE_END },
+ [ANDROID_FLASH] = { ANDROID_FLASH_START,
+ ANDROID_FLASH_END },
+ [ANDROID_FLASH_INFO] = { ANDROID_FLASH_INFO_START,
+ ANDROID_FLASH_INFO_END },
+ [ANDROID_GEOMETRIC] = { ANDROID_GEOMETRIC_START,
+ ANDROID_GEOMETRIC_END },
+ [ANDROID_HOT_PIXEL] = { ANDROID_HOT_PIXEL_START,
+ ANDROID_HOT_PIXEL_END },
+ [ANDROID_HOT_PIXEL_INFO] = { ANDROID_HOT_PIXEL_INFO_START,
+ ANDROID_HOT_PIXEL_INFO_END },
+ [ANDROID_JPEG] = { ANDROID_JPEG_START,
+ ANDROID_JPEG_END },
+ [ANDROID_LENS] = { ANDROID_LENS_START,
+ ANDROID_LENS_END },
+ [ANDROID_LENS_INFO] = { ANDROID_LENS_INFO_START,
+ ANDROID_LENS_INFO_END },
+ [ANDROID_NOISE_REDUCTION] = { ANDROID_NOISE_REDUCTION_START,
+ ANDROID_NOISE_REDUCTION_END },
+ [ANDROID_QUIRKS] = { ANDROID_QUIRKS_START,
+ ANDROID_QUIRKS_END },
+ [ANDROID_REQUEST] = { ANDROID_REQUEST_START,
+ ANDROID_REQUEST_END },
+ [ANDROID_SCALER] = { ANDROID_SCALER_START,
+ ANDROID_SCALER_END },
+ [ANDROID_SENSOR] = { ANDROID_SENSOR_START,
+ ANDROID_SENSOR_END },
+ [ANDROID_SENSOR_INFO] = { ANDROID_SENSOR_INFO_START,
+ ANDROID_SENSOR_INFO_END },
+ [ANDROID_SHADING] = { ANDROID_SHADING_START,
+ ANDROID_SHADING_END },
+ [ANDROID_STATISTICS] = { ANDROID_STATISTICS_START,
+ ANDROID_STATISTICS_END },
+ [ANDROID_STATISTICS_INFO] = { ANDROID_STATISTICS_INFO_START,
+ ANDROID_STATISTICS_INFO_END },
+ [ANDROID_TONEMAP] = { ANDROID_TONEMAP_START,
+ ANDROID_TONEMAP_END },
};
-// Shortcut defines to make succint names for field definitions
-#define TIDX(section, tag) \
- [ ANDROID_ ## section ## _ ## tag - ANDROID_ ## section ## _START ]
-
-#define TIIDX(section, tag) \
- [ ANDROID_ ## section ## _ ## tag - ANDROID_ ## section ## _INFO_START ]
-
-tag_info_t android_request[ANDROID_REQUEST_END -
- ANDROID_REQUEST_START] = {
- TIDX(REQUEST, ID) =
- { "id", TYPE_INT32 },
- TIDX(REQUEST, TYPE) =
- { "type", TYPE_BYTE },
- TIDX(REQUEST, METADATA_MODE) =
- { "metadataMode", TYPE_BYTE },
- TIDX(REQUEST, OUTPUT_STREAMS) =
- { "outputStreams", TYPE_BYTE },
- TIDX(REQUEST, INPUT_STREAMS) =
- { "inputStreams", TYPE_BYTE },
- TIDX(REQUEST, FRAME_COUNT) =
- { "frameCount", TYPE_INT32 }
+static tag_info_t android_color_correction[ANDROID_COLOR_CORRECTION_END -
+ ANDROID_COLOR_CORRECTION_START] = {
+ [ ANDROID_COLOR_CORRECTION_MODE - ANDROID_COLOR_CORRECTION_START ] =
+ { "mode", TYPE_BYTE },
+ [ ANDROID_COLOR_CORRECTION_TRANSFORM - ANDROID_COLOR_CORRECTION_START ] =
+ { "transform", TYPE_FLOAT },
};
-tag_info_t android_lens[ANDROID_LENS_END -
- ANDROID_LENS_START] = {
- TIDX(LENS, FOCUS_DISTANCE) =
- { "focusDistance", TYPE_FLOAT },
- TIDX(LENS, APERTURE) =
- { "aperture", TYPE_FLOAT },
- TIDX(LENS, FOCAL_LENGTH) =
- { "focalLength", TYPE_FLOAT },
- TIDX(LENS, FILTER_DENSITY) =
- { "filterDensity", TYPE_FLOAT },
- TIDX(LENS, OPTICAL_STABILIZATION_MODE) =
- { "opticalStabilizationMode", TYPE_BYTE },
- TIDX(LENS, FOCUS_RANGE) =
- { "focusRange", TYPE_FLOAT }
-};
-
-tag_info_t android_lens_info[ANDROID_LENS_INFO_END -
- ANDROID_LENS_INFO_START] = {
- TIIDX(LENS, MINIMUM_FOCUS_DISTANCE) =
- { "minimumFocusDistance", TYPE_FLOAT },
- TIIDX(LENS, HYPERFOCAL_DISTANCE) =
- { "hyperfocalDistance", TYPE_FLOAT },
- TIIDX(LENS, AVAILABLE_FOCAL_LENGTHS) =
- { "availableFocalLengths", TYPE_FLOAT },
- TIIDX(LENS, AVAILABLE_APERTURES) =
- { "availableApertures", TYPE_FLOAT },
- TIIDX(LENS, AVAILABLE_FILTER_DENSITY) =
- { "availableFilterDensities", TYPE_FLOAT },
- TIIDX(LENS, AVAILABLE_OPTICAL_STABILIZATION) =
- { "availableOpticalStabilizationModes", TYPE_BYTE },
- TIIDX(LENS, SHADING_MAP_SIZE) =
- { "shadingMapSize", TYPE_INT32 },
- TIIDX(LENS, SHADING_MAP) =
- { "shadingMap", TYPE_FLOAT },
- TIIDX(LENS, GEOMETRIC_CORRECTION_MAP_SIZE) =
- { "geometricCorrectionMapSize", TYPE_INT32 },
- TIIDX(LENS, GEOMETRIC_CORRECTION_MAP) =
- { "geometricCorrectionMap", TYPE_FLOAT },
- TIIDX(LENS, FACING) =
- { "facing", TYPE_BYTE },
- TIIDX(LENS, POSITION) =
- { "position", TYPE_FLOAT }
-};
-
-tag_info_t android_sensor[ANDROID_SENSOR_END -
- ANDROID_SENSOR_START] = {
- TIDX(SENSOR, EXPOSURE_TIME) =
- { "exposureTime", TYPE_INT64 },
- TIDX(SENSOR, FRAME_DURATION) =
- { "frameDuration", TYPE_INT64 },
- TIDX(SENSOR, SENSITIVITY) =
- { "sensitivity", TYPE_INT32 },
- TIDX(SENSOR, TIMESTAMP) =
- { "timestamp", TYPE_INT64 }
-};
-
-tag_info_t android_sensor_info[ANDROID_SENSOR_INFO_END -
- ANDROID_SENSOR_INFO_START] = {
- TIIDX(SENSOR, EXPOSURE_TIME_RANGE) =
- { "exposureTimeRange", TYPE_INT64 },
- TIIDX(SENSOR, MAX_FRAME_DURATION) =
- { "maxFrameDuration", TYPE_INT64 },
- TIIDX(SENSOR, AVAILABLE_SENSITIVITIES) =
- { "availableSensitivities", TYPE_INT32 },
- TIIDX(SENSOR, COLOR_FILTER_ARRANGEMENT) =
- { "colorFilterArrangement", TYPE_BYTE },
- TIIDX(SENSOR, PHYSICAL_SIZE) =
- { "physicalSize", TYPE_FLOAT },
- TIIDX(SENSOR, PIXEL_ARRAY_SIZE) =
- { "pixelArraySize", TYPE_INT32 },
- TIIDX(SENSOR, ACTIVE_ARRAY_SIZE) =
- { "activeArraySize", TYPE_INT32 },
- TIIDX(SENSOR, WHITE_LEVEL) =
- { "whiteLevel", TYPE_INT32 },
- TIIDX(SENSOR, BLACK_LEVEL_PATTERN) =
- { "blackLevelPattern", TYPE_INT32 },
- TIIDX(SENSOR, COLOR_TRANSFORM_1) =
- { "colorTransform1", TYPE_RATIONAL },
- TIIDX(SENSOR, COLOR_TRANSFORM_2) =
- { "colorTransform2", TYPE_RATIONAL },
- TIIDX(SENSOR, REFERENCE_ILLUMINANT_1) =
- { "referenceIlluminant1", TYPE_BYTE },
- TIIDX(SENSOR, REFERENCE_ILLUMINANT_2) =
- { "referenceIlluminant2", TYPE_BYTE },
- TIIDX(SENSOR, FORWARD_MATRIX_1) =
- { "forwardMatrix1", TYPE_RATIONAL },
- TIIDX(SENSOR, FORWARD_MATRIX_2) =
- { "forwardMatrix2", TYPE_RATIONAL },
- TIIDX(SENSOR, CALIBRATION_TRANSFORM_1) =
- { "calibrationTransform1", TYPE_RATIONAL },
- TIIDX(SENSOR, CALIBRATION_TRANSFORM_2) =
- { "calibrationTransform2", TYPE_RATIONAL },
- TIIDX(SENSOR, BASE_GAIN_FACTOR) =
- { "baseGainFactor", TYPE_RATIONAL },
- TIIDX(SENSOR, MAX_ANALOG_SENSITIVITY) =
- { "maxAnalogSensitivity", TYPE_INT32 },
- TIIDX(SENSOR, NOISE_MODEL_COEFFICIENTS) =
- { "noiseModelCoefficients", TYPE_FLOAT },
- TIIDX(SENSOR, ORIENTATION) =
- { "orientation", TYPE_INT32 }
-};
-
-tag_info_t android_flash[ANDROID_FLASH_END -
- ANDROID_FLASH_START] = {
- TIDX(FLASH, MODE) =
- { "mode", TYPE_BYTE },
- TIDX(FLASH, FIRING_POWER) =
- { "firingPower", TYPE_BYTE },
- TIDX(FLASH, FIRING_TIME) =
- { "firingTime", TYPE_INT64 }
-};
-
-tag_info_t android_flash_info[ANDROID_FLASH_INFO_END -
- ANDROID_FLASH_INFO_START] = {
- TIIDX(FLASH, AVAILABLE) =
- { "available", TYPE_BYTE },
- TIIDX(FLASH, CHARGE_DURATION) =
- { "chargeDuration", TYPE_INT64 },
-};
-
-tag_info_t android_hot_pixel[ANDROID_HOT_PIXEL_END -
- ANDROID_HOT_PIXEL_START] = {
- TIDX(HOT_PIXEL, MODE) =
- { "mode", TYPE_BYTE }
-};
-
-tag_info_t android_hot_pixel_info[ANDROID_HOT_PIXEL_INFO_END -
- ANDROID_HOT_PIXEL_INFO_START];
-
-tag_info_t android_demosaic[ANDROID_DEMOSAIC_END -
- ANDROID_DEMOSAIC_START] = {
- TIDX(DEMOSAIC, MODE) =
- { "mode", TYPE_BYTE }
-};
-
-tag_info_t android_demosaic_info[ANDROID_DEMOSAIC_INFO_END -
- ANDROID_DEMOSAIC_INFO_START];
-
-tag_info_t android_noise[ANDROID_NOISE_END -
- ANDROID_NOISE_START] = {
- TIDX(NOISE, MODE) =
- { "mode", TYPE_BYTE },
- TIDX(NOISE, STRENGTH) =
- { "strength", TYPE_BYTE }
-};
-
-tag_info_t android_noise_info[ANDROID_NOISE_INFO_END -
- ANDROID_NOISE_INFO_START];
-
-tag_info_t android_shading[ANDROID_SHADING_END -
- ANDROID_SHADING_START] = {
- TIDX(SHADING, MODE) =
- { "mode", TYPE_BYTE }
-};
-
-tag_info_t android_shading_info[ANDROID_SHADING_INFO_END -
- ANDROID_SHADING_INFO_START];
-
-tag_info_t android_geometric[ANDROID_GEOMETRIC_END -
- ANDROID_GEOMETRIC_START] = {
- TIDX(GEOMETRIC, MODE) =
- { "mode", TYPE_BYTE }
-};
-
-tag_info_t android_geometric_info[ANDROID_GEOMETRIC_INFO_END -
- ANDROID_GEOMETRIC_INFO_START];
-
-tag_info_t android_color[ANDROID_COLOR_END -
- ANDROID_COLOR_START] = {
- TIDX(COLOR, MODE) =
- { "mode", TYPE_BYTE },
- TIDX(COLOR, TRANSFORM) =
- { "transform", TYPE_FLOAT }
-};
-
-tag_info_t android_color_info[ANDROID_COLOR_INFO_END -
- ANDROID_COLOR_INFO_START];
-
-tag_info_t android_tonemap[ANDROID_TONEMAP_END -
- ANDROID_TONEMAP_START] = {
- TIDX(TONEMAP, MODE) =
- { "mode", TYPE_BYTE },
- TIDX(TONEMAP, CURVE_RED) =
- { "curveRed", TYPE_FLOAT },
- TIDX(TONEMAP, CURVE_GREEN) =
- { "curveGreen", TYPE_FLOAT },
- TIDX(TONEMAP, CURVE_BLUE) =
- { "curveBlue", TYPE_FLOAT }
-};
-
-tag_info_t android_tonemap_info[ANDROID_TONEMAP_INFO_END -
- ANDROID_TONEMAP_INFO_START] = {
- TIIDX(TONEMAP, MAX_CURVE_POINTS) =
- { "maxCurvePoints", TYPE_INT32 }
-};
-
-tag_info_t android_edge[ANDROID_EDGE_END -
- ANDROID_EDGE_START] = {
- TIDX(EDGE, MODE) =
- { "mode", TYPE_BYTE },
- TIDX(EDGE, STRENGTH) =
- { "strength", TYPE_BYTE }
-};
-
-tag_info_t android_edge_info[ANDROID_EDGE_INFO_END -
- ANDROID_EDGE_INFO_START];
-
-tag_info_t android_scaler[ANDROID_SCALER_END -
- ANDROID_SCALER_START] = {
- TIDX(SCALER, CROP_REGION) =
- { "cropRegion", TYPE_INT32 }
-};
-
-tag_info_t android_scaler_info[ANDROID_SCALER_INFO_END -
- ANDROID_SCALER_INFO_START] = {
- TIIDX(SCALER, AVAILABLE_FORMATS) =
- { "availableFormats", TYPE_INT32 },
- TIIDX(SCALER, AVAILABLE_RAW_SIZES) =
- { "availableRawSizes", TYPE_INT32 },
- TIIDX(SCALER, AVAILABLE_RAW_MIN_DURATIONS) =
- { "availableRawMinDurations", TYPE_INT64 },
- TIIDX(SCALER, AVAILABLE_PROCESSED_SIZES) =
- { "availableProcessedSizes", TYPE_INT32 },
- TIIDX(SCALER, AVAILABLE_PROCESSED_MIN_DURATIONS) =
- { "availableProcessedMinDurations", TYPE_INT64 },
- TIIDX(SCALER, AVAILABLE_JPEG_SIZES) =
- { "availableJpegSizes", TYPE_INT32 },
- TIIDX(SCALER, AVAILABLE_JPEG_MIN_DURATIONS) =
- { "availableJpegMinDurations", TYPE_INT64 },
- TIIDX(SCALER, AVAILABLE_MAX_ZOOM) =
- { "availableMaxDigitalZoom", TYPE_INT32 }
-};
-
-tag_info_t android_jpeg[ANDROID_JPEG_END -
- ANDROID_JPEG_START] = {
- TIDX(JPEG, QUALITY) =
- { "quality", TYPE_INT32 },
- TIDX(JPEG, THUMBNAIL_SIZE) =
- { "thumbnailSize", TYPE_INT32 },
- TIDX(JPEG, THUMBNAIL_QUALITY) =
- { "thumbnailQuality", TYPE_INT32 },
- TIDX(JPEG, GPS_COORDINATES) =
- { "gpsCoordinates", TYPE_DOUBLE },
- TIDX(JPEG, GPS_PROCESSING_METHOD) =
- { "gpsProcessingMethod", TYPE_BYTE },
- TIDX(JPEG, GPS_TIMESTAMP) =
- { "gpsTimestamp", TYPE_INT64 },
- TIDX(JPEG, ORIENTATION) =
- { "orientation", TYPE_INT32 },
- TIDX(JPEG, SIZE) =
- { "size", TYPE_INT32 }
-};
-
-tag_info_t android_jpeg_info[ANDROID_JPEG_INFO_END -
- ANDROID_JPEG_INFO_START] = {
- TIIDX(JPEG, AVAILABLE_THUMBNAIL_SIZES) =
- { "availableThumbnailSizes", TYPE_INT32 },
- TIIDX(JPEG, MAX_SIZE) =
- { "maxSize", TYPE_INT32 }
-};
-
-tag_info_t android_stats[ANDROID_STATS_END -
- ANDROID_STATS_START] = {
- TIDX(STATS, FACE_DETECT_MODE) =
- { "faceDetectMode", TYPE_BYTE },
- TIDX(STATS, FACE_RECTANGLES) =
- { "faceRectangles", TYPE_INT32 },
- TIDX(STATS, FACE_SCORES) =
- { "faceScores", TYPE_BYTE },
- TIDX(STATS, FACE_LANDMARKS) =
- { "faceLandmarks", TYPE_INT32 },
- TIDX(STATS, FACE_IDS) =
- { "faceIds", TYPE_INT32 },
- TIDX(STATS, HISTOGRAM_MODE) =
- { "histogramMode", TYPE_BYTE },
- TIDX(STATS, HISTOGRAM) =
- { "histogram", TYPE_INT32 },
- TIDX(STATS, SHARPNESS_MAP_MODE) =
- { "sharpnessMapMode", TYPE_BYTE },
- TIDX(STATS, SHARPNESS_MAP) =
- { "sharpnessMap", TYPE_INT32 }
-};
-
-tag_info_t android_stats_info[ANDROID_STATS_INFO_END -
- ANDROID_STATS_INFO_START] = {
- TIIDX(STATS, AVAILABLE_FACE_DETECT_MODES) =
- { "availableFaceDetectModes", TYPE_BYTE },
- TIIDX(STATS, MAX_FACE_COUNT) =
- { "maxFaceCount", TYPE_INT32 },
- TIIDX(STATS, HISTOGRAM_BUCKET_COUNT) =
- { "histogramBucketCount", TYPE_INT32 },
- TIIDX(STATS, MAX_HISTOGRAM_COUNT) =
- { "maxHistogramCount", TYPE_INT32 },
- TIIDX(STATS, SHARPNESS_MAP_SIZE) =
- { "sharpnessMapSize", TYPE_INT32 },
- TIIDX(STATS, MAX_SHARPNESS_MAP_VALUE) =
- { "maxSharpnessMapValue", TYPE_INT32 }
-};
-
-
-tag_info_t android_control[ANDROID_CONTROL_END -
+static tag_info_t android_control[ANDROID_CONTROL_END -
ANDROID_CONTROL_START] = {
- TIDX(CONTROL, CAPTURE_INTENT) =
- { "captureIntent", TYPE_BYTE },
- TIDX(CONTROL, MODE) =
- { "mode", TYPE_BYTE },
- TIDX(CONTROL, EFFECT_MODE) =
- { "effectMode", TYPE_BYTE },
- TIDX(CONTROL, SCENE_MODE) =
- { "sceneMode", TYPE_BYTE },
- TIDX(CONTROL, VIDEO_STABILIZATION_MODE) =
- { "videoStabilizationMode", TYPE_BYTE },
- TIDX(CONTROL, AE_MODE) =
- { "aeMode", TYPE_BYTE },
- TIDX(CONTROL, AE_LOCK) =
- { "aeLock", TYPE_BYTE },
- TIDX(CONTROL, AE_REGIONS) =
- { "aeRegions", TYPE_INT32 },
- TIDX(CONTROL, AE_EXP_COMPENSATION) =
- { "aeExposureCompensation", TYPE_INT32 },
- TIDX(CONTROL, AE_TARGET_FPS_RANGE) =
- { "aeTargetFpsRange", TYPE_INT32 },
- TIDX(CONTROL, AE_ANTIBANDING_MODE) =
- { "aeAntibandingMode", TYPE_BYTE },
- TIDX(CONTROL, AE_STATE) =
- { "aeState", TYPE_BYTE },
- TIDX(CONTROL, AE_PRECAPTURE_ID) =
- { "aePrecaptureId", TYPE_INT32},
- TIDX(CONTROL, AWB_MODE) =
- { "awbMode", TYPE_BYTE },
- TIDX(CONTROL, AWB_LOCK) =
- { "awbLock", TYPE_BYTE },
- TIDX(CONTROL, AWB_REGIONS) =
- { "awbRegions", TYPE_INT32 },
- TIDX(CONTROL, AWB_STATE) =
- { "awbState", TYPE_BYTE },
- TIDX(CONTROL, AF_MODE) =
- { "afMode", TYPE_BYTE },
- TIDX(CONTROL, AF_REGIONS) =
- { "afRegions", TYPE_INT32 },
- TIDX(CONTROL, AF_STATE) =
- { "afState", TYPE_BYTE },
- TIDX(CONTROL, AF_TRIGGER_ID) =
- { "afTriggerId", TYPE_INT32 }
+ [ ANDROID_CONTROL_AE_ANTIBANDING_MODE - ANDROID_CONTROL_START ] =
+ { "aeAntibandingMode", TYPE_BYTE },
+ [ ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION - ANDROID_CONTROL_START ] =
+ { "aeExposureCompensation", TYPE_INT32 },
+ [ ANDROID_CONTROL_AE_LOCK - ANDROID_CONTROL_START ] =
+ { "aeLock", TYPE_BYTE },
+ [ ANDROID_CONTROL_AE_MODE - ANDROID_CONTROL_START ] =
+ { "aeMode", TYPE_BYTE },
+ [ ANDROID_CONTROL_AE_REGIONS - ANDROID_CONTROL_START ] =
+ { "aeRegions", TYPE_INT32 },
+ [ ANDROID_CONTROL_AE_TARGET_FPS_RANGE - ANDROID_CONTROL_START ] =
+ { "aeTargetFpsRange", TYPE_INT32 },
+ [ ANDROID_CONTROL_AF_MODE - ANDROID_CONTROL_START ] =
+ { "afMode", TYPE_BYTE },
+ [ ANDROID_CONTROL_AF_REGIONS - ANDROID_CONTROL_START ] =
+ { "afRegions", TYPE_INT32 },
+ [ ANDROID_CONTROL_AWB_LOCK - ANDROID_CONTROL_START ] =
+ { "awbLock", TYPE_BYTE },
+ [ ANDROID_CONTROL_AWB_MODE - ANDROID_CONTROL_START ] =
+ { "awbMode", TYPE_BYTE },
+ [ ANDROID_CONTROL_AWB_REGIONS - ANDROID_CONTROL_START ] =
+ { "awbRegions", TYPE_INT32 },
+ [ ANDROID_CONTROL_CAPTURE_INTENT - ANDROID_CONTROL_START ] =
+ { "captureIntent", TYPE_BYTE },
+ [ ANDROID_CONTROL_EFFECT_MODE - ANDROID_CONTROL_START ] =
+ { "effectMode", TYPE_BYTE },
+ [ ANDROID_CONTROL_MODE - ANDROID_CONTROL_START ] =
+ { "mode", TYPE_BYTE },
+ [ ANDROID_CONTROL_SCENE_MODE - ANDROID_CONTROL_START ] =
+ { "sceneMode", TYPE_BYTE },
+ [ ANDROID_CONTROL_VIDEO_STABILIZATION_MODE - ANDROID_CONTROL_START ] =
+ { "videoStabilizationMode", TYPE_BYTE },
+ [ ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES - ANDROID_CONTROL_START ] =
+ { "aeAvailableAntibandingModes", TYPE_BYTE },
+ [ ANDROID_CONTROL_AE_AVAILABLE_MODES - ANDROID_CONTROL_START ] =
+ { "aeAvailableModes", TYPE_BYTE },
+ [ ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES - ANDROID_CONTROL_START ] =
+ { "aeAvailableTargetFpsRanges", TYPE_INT32 },
+ [ ANDROID_CONTROL_AE_COMPENSATION_RANGE - ANDROID_CONTROL_START ] =
+ { "aeCompensationRange", TYPE_INT32 },
+ [ ANDROID_CONTROL_AE_COMPENSATION_STEP - ANDROID_CONTROL_START ] =
+ { "aeCompensationStep", TYPE_RATIONAL
+ },
+ [ ANDROID_CONTROL_AF_AVAILABLE_MODES - ANDROID_CONTROL_START ] =
+ { "afAvailableModes", TYPE_BYTE },
+ [ ANDROID_CONTROL_AVAILABLE_EFFECTS - ANDROID_CONTROL_START ] =
+ { "availableEffects", TYPE_BYTE },
+ [ ANDROID_CONTROL_AVAILABLE_SCENE_MODES - ANDROID_CONTROL_START ] =
+ { "availableSceneModes", TYPE_BYTE },
+ [ ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES - ANDROID_CONTROL_START ] =
+ { "availableVideoStabilizationModes",
+ TYPE_BYTE },
+ [ ANDROID_CONTROL_AWB_AVAILABLE_MODES - ANDROID_CONTROL_START ] =
+ { "awbAvailableModes", TYPE_BYTE },
+ [ ANDROID_CONTROL_MAX_REGIONS - ANDROID_CONTROL_START ] =
+ { "maxRegions", TYPE_INT32 },
+ [ ANDROID_CONTROL_SCENE_MODE_OVERRIDES - ANDROID_CONTROL_START ] =
+ { "sceneModeOverrides", TYPE_BYTE },
+ [ ANDROID_CONTROL_AE_PRECAPTURE_ID - ANDROID_CONTROL_START ] =
+ { "aePrecaptureId", TYPE_INT32 },
+ [ ANDROID_CONTROL_AE_STATE - ANDROID_CONTROL_START ] =
+ { "aeState", TYPE_BYTE },
+ [ ANDROID_CONTROL_AF_STATE - ANDROID_CONTROL_START ] =
+ { "afState", TYPE_BYTE },
+ [ ANDROID_CONTROL_AF_TRIGGER_ID - ANDROID_CONTROL_START ] =
+ { "afTriggerId", TYPE_INT32 },
+ [ ANDROID_CONTROL_AWB_STATE - ANDROID_CONTROL_START ] =
+ { "awbState", TYPE_BYTE },
};
-tag_info_t android_control_info[ANDROID_CONTROL_INFO_END -
- ANDROID_CONTROL_INFO_START] = {
- TIIDX(CONTROL, AVAILABLE_SCENE_MODES) =
- { "availableSceneModes", TYPE_BYTE },
- TIIDX(CONTROL, AVAILABLE_EFFECTS) =
- { "availableEffects", TYPE_BYTE },
- TIIDX(CONTROL, MAX_REGIONS) =
- { "maxRegions", TYPE_INT32 },
- TIIDX(CONTROL, AE_AVAILABLE_MODES) =
- { "aeAvailableModes", TYPE_BYTE },
- TIIDX(CONTROL, AE_EXP_COMPENSATION_STEP) =
- { "aeCompensationStep", TYPE_RATIONAL },
- TIIDX(CONTROL, AE_EXP_COMPENSATION_RANGE) =
- { "aeCompensationRange", TYPE_INT32 },
- TIIDX(CONTROL, AE_AVAILABLE_TARGET_FPS_RANGES) =
- { "aeAvailableTargetFpsRanges", TYPE_INT32 },
- TIIDX(CONTROL, AE_AVAILABLE_ANTIBANDING_MODES) =
- { "aeAvailableAntibandingModes", TYPE_BYTE },
- TIIDX(CONTROL, AWB_AVAILABLE_MODES) =
- { "awbAvailableModes", TYPE_BYTE },
- TIIDX(CONTROL, AF_AVAILABLE_MODES) =
- { "afAvailableModes", TYPE_BYTE },
- TIIDX(CONTROL, AVAILABLE_VIDEO_STABILIZATION_MODES) =
- { "availableVideoStabilizationModes", TYPE_BYTE },
- TIIDX(CONTROL, SCENE_MODE_OVERRIDES) =
- { "sceneModeOverrides", TYPE_BYTE }
+static tag_info_t android_demosaic[ANDROID_DEMOSAIC_END -
+ ANDROID_DEMOSAIC_START] = {
+ [ ANDROID_DEMOSAIC_MODE - ANDROID_DEMOSAIC_START ] =
+ { "mode", TYPE_BYTE },
};
-tag_info_t android_quirks_info[ANDROID_QUIRKS_INFO_END -
- ANDROID_QUIRKS_INFO_START] = {
- TIIDX(QUIRKS, TRIGGER_AF_WITH_AUTO) =
- { "triggerAfWithAuto", TYPE_BYTE },
- TIIDX(QUIRKS, USE_ZSL_FORMAT) =
- { "useZslFormat", TYPE_BYTE },
- TIIDX(QUIRKS, METERING_CROP_REGION) =
- { "meteringCropRegion", TYPE_BYTE },
+static tag_info_t android_edge[ANDROID_EDGE_END -
+ ANDROID_EDGE_START] = {
+ [ ANDROID_EDGE_MODE - ANDROID_EDGE_START ] =
+ { "mode", TYPE_BYTE },
+ [ ANDROID_EDGE_STRENGTH - ANDROID_EDGE_START ] =
+ { "strength", TYPE_BYTE },
};
-#undef TIDX
-#undef TIIDX
+static tag_info_t android_flash[ANDROID_FLASH_END -
+ ANDROID_FLASH_START] = {
+ [ ANDROID_FLASH_FIRING_POWER - ANDROID_FLASH_START ] =
+ { "firingPower", TYPE_BYTE },
+ [ ANDROID_FLASH_FIRING_TIME - ANDROID_FLASH_START ] =
+ { "firingTime", TYPE_INT64 },
+ [ ANDROID_FLASH_MODE - ANDROID_FLASH_START ] =
+ { "mode", TYPE_BYTE },
+ [ ANDROID_FLASH_COLOR_TEMPERATURE - ANDROID_FLASH_START ] =
+ { "colorTemperature", TYPE_BYTE },
+ [ ANDROID_FLASH_MAX_ENERGY - ANDROID_FLASH_START ] =
+ { "maxEnergy", TYPE_BYTE },
+ [ ANDROID_FLASH_STATE - ANDROID_FLASH_START ] =
+ { "state", TYPE_BYTE },
+};
+
+static tag_info_t android_flash_info[ANDROID_FLASH_INFO_END -
+ ANDROID_FLASH_INFO_START] = {
+ [ ANDROID_FLASH_INFO_AVAILABLE - ANDROID_FLASH_INFO_START ] =
+ { "available", TYPE_BYTE },
+ [ ANDROID_FLASH_INFO_CHARGE_DURATION - ANDROID_FLASH_INFO_START ] =
+ { "chargeDuration", TYPE_INT64 },
+};
+
+static tag_info_t android_geometric[ANDROID_GEOMETRIC_END -
+ ANDROID_GEOMETRIC_START] = {
+ [ ANDROID_GEOMETRIC_MODE - ANDROID_GEOMETRIC_START ] =
+ { "mode", TYPE_BYTE },
+ [ ANDROID_GEOMETRIC_STRENGTH - ANDROID_GEOMETRIC_START ] =
+ { "strength", TYPE_BYTE },
+};
+
+static tag_info_t android_hot_pixel[ANDROID_HOT_PIXEL_END -
+ ANDROID_HOT_PIXEL_START] = {
+ [ ANDROID_HOT_PIXEL_MODE - ANDROID_HOT_PIXEL_START ] =
+ { "mode", TYPE_BYTE },
+};
+
+static tag_info_t android_hot_pixel_info[ANDROID_HOT_PIXEL_INFO_END -
+ ANDROID_HOT_PIXEL_INFO_START] = {
+ [ ANDROID_HOT_PIXEL_INFO_MAP - ANDROID_HOT_PIXEL_INFO_START ] =
+ { "map", TYPE_INT32 },
+};
+
+static tag_info_t android_jpeg[ANDROID_JPEG_END -
+ ANDROID_JPEG_START] = {
+ [ ANDROID_JPEG_GPS_COORDINATES - ANDROID_JPEG_START ] =
+ { "gpsCoordinates", TYPE_DOUBLE },
+ [ ANDROID_JPEG_GPS_PROCESSING_METHOD - ANDROID_JPEG_START ] =
+ { "gpsProcessingMethod", TYPE_BYTE },
+ [ ANDROID_JPEG_GPS_TIMESTAMP - ANDROID_JPEG_START ] =
+ { "gpsTimestamp", TYPE_INT64 },
+ [ ANDROID_JPEG_ORIENTATION - ANDROID_JPEG_START ] =
+ { "orientation", TYPE_INT32 },
+ [ ANDROID_JPEG_QUALITY - ANDROID_JPEG_START ] =
+ { "quality", TYPE_BYTE },
+ [ ANDROID_JPEG_THUMBNAIL_QUALITY - ANDROID_JPEG_START ] =
+ { "thumbnailQuality", TYPE_BYTE },
+ [ ANDROID_JPEG_THUMBNAIL_SIZE - ANDROID_JPEG_START ] =
+ { "thumbnailSize", TYPE_INT32 },
+ [ ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES - ANDROID_JPEG_START ] =
+ { "availableThumbnailSizes", TYPE_INT32 },
+ [ ANDROID_JPEG_MAX_SIZE - ANDROID_JPEG_START ] =
+ { "maxSize", TYPE_INT32 },
+ [ ANDROID_JPEG_SIZE - ANDROID_JPEG_START ] =
+ { "size", TYPE_INT32 },
+};
+
+static tag_info_t android_lens[ANDROID_LENS_END -
+ ANDROID_LENS_START] = {
+ [ ANDROID_LENS_APERTURE - ANDROID_LENS_START ] =
+ { "aperture", TYPE_FLOAT },
+ [ ANDROID_LENS_FILTER_DENSITY - ANDROID_LENS_START ] =
+ { "filterDensity", TYPE_FLOAT },
+ [ ANDROID_LENS_FOCAL_LENGTH - ANDROID_LENS_START ] =
+ { "focalLength", TYPE_FLOAT },
+ [ ANDROID_LENS_FOCUS_DISTANCE - ANDROID_LENS_START ] =
+ { "focusDistance", TYPE_FLOAT },
+ [ ANDROID_LENS_OPTICAL_STABILIZATION_MODE - ANDROID_LENS_START ] =
+ { "opticalStabilizationMode", TYPE_BYTE },
+ [ ANDROID_LENS_FACING - ANDROID_LENS_START ] =
+ { "facing", TYPE_BYTE },
+ [ ANDROID_LENS_OPTICAL_AXIS_ANGLE - ANDROID_LENS_START ] =
+ { "opticalAxisAngle", TYPE_FLOAT },
+ [ ANDROID_LENS_POSITION - ANDROID_LENS_START ] =
+ { "position", TYPE_FLOAT },
+ [ ANDROID_LENS_FOCUS_RANGE - ANDROID_LENS_START ] =
+ { "focusRange", TYPE_FLOAT },
+ [ ANDROID_LENS_STATE - ANDROID_LENS_START ] =
+ { "state", TYPE_BYTE },
+};
+
+static tag_info_t android_lens_info[ANDROID_LENS_INFO_END -
+ ANDROID_LENS_INFO_START] = {
+ [ ANDROID_LENS_INFO_AVAILABLE_APERTURES - ANDROID_LENS_INFO_START ] =
+ { "availableApertures", TYPE_FLOAT },
+ [ ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES - ANDROID_LENS_INFO_START ] =
+ { "availableFilterDensities", TYPE_FLOAT },
+ [ ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS - ANDROID_LENS_INFO_START ] =
+ { "availableFocalLengths", TYPE_FLOAT },
+ [ ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION - ANDROID_LENS_INFO_START ] =
+ { "availableOpticalStabilization", TYPE_BYTE },
+ [ ANDROID_LENS_INFO_GEOMETRIC_CORRECTION_MAP - ANDROID_LENS_INFO_START ] =
+ { "geometricCorrectionMap", TYPE_FLOAT },
+ [ ANDROID_LENS_INFO_GEOMETRIC_CORRECTION_MAP_SIZE - ANDROID_LENS_INFO_START ] =
+ { "geometricCorrectionMapSize", TYPE_INT32 },
+ [ ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE - ANDROID_LENS_INFO_START ] =
+ { "hyperfocalDistance", TYPE_FLOAT },
+ [ ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE - ANDROID_LENS_INFO_START ] =
+ { "minimumFocusDistance", TYPE_FLOAT },
+ [ ANDROID_LENS_INFO_SHADING_MAP - ANDROID_LENS_INFO_START ] =
+ { "shadingMap", TYPE_FLOAT },
+ [ ANDROID_LENS_INFO_SHADING_MAP_SIZE - ANDROID_LENS_INFO_START ] =
+ { "shadingMapSize", TYPE_INT32 },
+};
+
+static tag_info_t android_noise_reduction[ANDROID_NOISE_REDUCTION_END -
+ ANDROID_NOISE_REDUCTION_START] = {
+ [ ANDROID_NOISE_REDUCTION_MODE - ANDROID_NOISE_REDUCTION_START ] =
+ { "mode", TYPE_BYTE },
+ [ ANDROID_NOISE_REDUCTION_STRENGTH - ANDROID_NOISE_REDUCTION_START ] =
+ { "strength", TYPE_BYTE },
+};
+
+static tag_info_t android_quirks[ANDROID_QUIRKS_END -
+ ANDROID_QUIRKS_START] = {
+ [ ANDROID_QUIRKS_METERING_CROP_REGION - ANDROID_QUIRKS_START ] =
+ { "meteringCropRegion", TYPE_BYTE },
+ [ ANDROID_QUIRKS_TRIGGER_AF_WITH_AUTO - ANDROID_QUIRKS_START ] =
+ { "triggerAfWithAuto", TYPE_BYTE },
+ [ ANDROID_QUIRKS_USE_ZSL_FORMAT - ANDROID_QUIRKS_START ] =
+ { "useZslFormat", TYPE_BYTE },
+};
+
+static tag_info_t android_request[ANDROID_REQUEST_END -
+ ANDROID_REQUEST_START] = {
+ [ ANDROID_REQUEST_FRAME_COUNT - ANDROID_REQUEST_START ] =
+ { "frameCount", TYPE_INT32 },
+ [ ANDROID_REQUEST_ID - ANDROID_REQUEST_START ] =
+ { "id", TYPE_INT32 },
+ [ ANDROID_REQUEST_INPUT_STREAMS - ANDROID_REQUEST_START ] =
+ { "inputStreams", TYPE_BYTE },
+ [ ANDROID_REQUEST_METADATA_MODE - ANDROID_REQUEST_START ] =
+ { "metadataMode", TYPE_BYTE },
+ [ ANDROID_REQUEST_OUTPUT_STREAMS - ANDROID_REQUEST_START ] =
+ { "outputStreams", TYPE_BYTE },
+ [ ANDROID_REQUEST_TYPE - ANDROID_REQUEST_START ] =
+ { "type", TYPE_BYTE },
+ [ ANDROID_REQUEST_MAX_NUM_OUTPUT_STREAMS - ANDROID_REQUEST_START ] =
+ { "maxNumOutputStreams", TYPE_INT32 },
+ [ ANDROID_REQUEST_MAX_NUM_REPROCESS_STREAMS - ANDROID_REQUEST_START ] =
+ { "maxNumReprocessStreams", TYPE_INT32 },
+};
+
+static tag_info_t android_scaler[ANDROID_SCALER_END -
+ ANDROID_SCALER_START] = {
+ [ ANDROID_SCALER_CROP_REGION - ANDROID_SCALER_START ] =
+ { "cropRegion", TYPE_INT32 },
+ [ ANDROID_SCALER_AVAILABLE_FORMATS - ANDROID_SCALER_START ] =
+ { "availableFormats", TYPE_INT32 },
+ [ ANDROID_SCALER_AVAILABLE_JPEG_MIN_DURATIONS - ANDROID_SCALER_START ] =
+ { "availableJpegMinDurations", TYPE_INT64 },
+ [ ANDROID_SCALER_AVAILABLE_JPEG_SIZES - ANDROID_SCALER_START ] =
+ { "availableJpegSizes", TYPE_INT32 },
+ [ ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM - ANDROID_SCALER_START ] =
+ { "availableMaxDigitalZoom", TYPE_INT32 },
+ [ ANDROID_SCALER_AVAILABLE_PROCESSED_MIN_DURATIONS - ANDROID_SCALER_START ] =
+ { "availableProcessedMinDurations",
+ TYPE_INT64 },
+ [ ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES - ANDROID_SCALER_START ] =
+ { "availableProcessedSizes", TYPE_INT32 },
+ [ ANDROID_SCALER_AVAILABLE_RAW_MIN_DURATIONS - ANDROID_SCALER_START ] =
+ { "availableRawMinDurations", TYPE_INT64 },
+ [ ANDROID_SCALER_AVAILABLE_RAW_SIZES - ANDROID_SCALER_START ] =
+ { "availableRawSizes", TYPE_INT32 },
+ [ ANDROID_SCALER_MAX_DIGITAL_ZOOM - ANDROID_SCALER_START ] =
+ { "maxDigitalZoom", TYPE_FLOAT },
+};
+
+static tag_info_t android_sensor[ANDROID_SENSOR_END -
+ ANDROID_SENSOR_START] = {
+ [ ANDROID_SENSOR_EXPOSURE_TIME - ANDROID_SENSOR_START ] =
+ { "exposureTime", TYPE_INT64 },
+ [ ANDROID_SENSOR_FRAME_DURATION - ANDROID_SENSOR_START ] =
+ { "frameDuration", TYPE_INT64 },
+ [ ANDROID_SENSOR_SENSITIVITY - ANDROID_SENSOR_START ] =
+ { "sensitivity", TYPE_INT32 },
+ [ ANDROID_SENSOR_BASE_GAIN_FACTOR - ANDROID_SENSOR_START ] =
+ { "baseGainFactor", TYPE_RATIONAL
+ },
+ [ ANDROID_SENSOR_BLACK_LEVEL_PATTERN - ANDROID_SENSOR_START ] =
+ { "blackLevelPattern", TYPE_INT32 },
+ [ ANDROID_SENSOR_CALIBRATION_TRANSFORM1 - ANDROID_SENSOR_START ] =
+ { "calibrationTransform1", TYPE_RATIONAL
+ },
+ [ ANDROID_SENSOR_CALIBRATION_TRANSFORM2 - ANDROID_SENSOR_START ] =
+ { "calibrationTransform2", TYPE_RATIONAL
+ },
+ [ ANDROID_SENSOR_COLOR_TRANSFORM1 - ANDROID_SENSOR_START ] =
+ { "colorTransform1", TYPE_RATIONAL
+ },
+ [ ANDROID_SENSOR_COLOR_TRANSFORM2 - ANDROID_SENSOR_START ] =
+ { "colorTransform2", TYPE_RATIONAL
+ },
+ [ ANDROID_SENSOR_FORWARD_MATRIX1 - ANDROID_SENSOR_START ] =
+ { "forwardMatrix1", TYPE_RATIONAL
+ },
+ [ ANDROID_SENSOR_FORWARD_MATRIX2 - ANDROID_SENSOR_START ] =
+ { "forwardMatrix2", TYPE_RATIONAL
+ },
+ [ ANDROID_SENSOR_MAX_ANALOG_SENSITIVITY - ANDROID_SENSOR_START ] =
+ { "maxAnalogSensitivity", TYPE_INT32 },
+ [ ANDROID_SENSOR_NOISE_MODEL_COEFFICIENTS - ANDROID_SENSOR_START ] =
+ { "noiseModelCoefficients", TYPE_FLOAT },
+ [ ANDROID_SENSOR_ORIENTATION - ANDROID_SENSOR_START ] =
+ { "orientation", TYPE_INT32 },
+ [ ANDROID_SENSOR_REFERENCE_ILLUMINANT1 - ANDROID_SENSOR_START ] =
+ { "referenceIlluminant1", TYPE_BYTE },
+ [ ANDROID_SENSOR_REFERENCE_ILLUMINANT2 - ANDROID_SENSOR_START ] =
+ { "referenceIlluminant2", TYPE_BYTE },
+ [ ANDROID_SENSOR_TIMESTAMP - ANDROID_SENSOR_START ] =
+ { "timestamp", TYPE_INT64 },
+};
+
+static tag_info_t android_sensor_info[ANDROID_SENSOR_INFO_END -
+ ANDROID_SENSOR_INFO_START] = {
+ [ ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE - ANDROID_SENSOR_INFO_START ] =
+ { "activeArraySize", TYPE_INT32 },
+ [ ANDROID_SENSOR_INFO_AVAILABLE_SENSITIVITIES - ANDROID_SENSOR_INFO_START ] =
+ { "availableSensitivities", TYPE_INT32 },
+ [ ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT - ANDROID_SENSOR_INFO_START ] =
+ { "colorFilterArrangement", TYPE_BYTE },
+ [ ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE - ANDROID_SENSOR_INFO_START ] =
+ { "exposureTimeRange", TYPE_INT64 },
+ [ ANDROID_SENSOR_INFO_MAX_FRAME_DURATION - ANDROID_SENSOR_INFO_START ] =
+ { "maxFrameDuration", TYPE_INT64 },
+ [ ANDROID_SENSOR_INFO_PHYSICAL_SIZE - ANDROID_SENSOR_INFO_START ] =
+ { "physicalSize", TYPE_FLOAT },
+ [ ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE - ANDROID_SENSOR_INFO_START ] =
+ { "pixelArraySize", TYPE_INT32 },
+ [ ANDROID_SENSOR_INFO_WHITE_LEVEL - ANDROID_SENSOR_INFO_START ] =
+ { "whiteLevel", TYPE_INT32 },
+};
+
+static tag_info_t android_shading[ANDROID_SHADING_END -
+ ANDROID_SHADING_START] = {
+ [ ANDROID_SHADING_MODE - ANDROID_SHADING_START ] =
+ { "mode", TYPE_BYTE },
+ [ ANDROID_SHADING_STRENGTH - ANDROID_SHADING_START ] =
+ { "strength", TYPE_BYTE },
+};
+
+static tag_info_t android_statistics[ANDROID_STATISTICS_END -
+ ANDROID_STATISTICS_START] = {
+ [ ANDROID_STATISTICS_FACE_DETECT_MODE - ANDROID_STATISTICS_START ] =
+ { "faceDetectMode", TYPE_BYTE },
+ [ ANDROID_STATISTICS_HISTOGRAM_MODE - ANDROID_STATISTICS_START ] =
+ { "histogramMode", TYPE_BYTE },
+ [ ANDROID_STATISTICS_SHARPNESS_MAP_MODE - ANDROID_STATISTICS_START ] =
+ { "sharpnessMapMode", TYPE_BYTE },
+ [ ANDROID_STATISTICS_FACE_IDS - ANDROID_STATISTICS_START ] =
+ { "faceIds", TYPE_INT32 },
+ [ ANDROID_STATISTICS_FACE_LANDMARKS - ANDROID_STATISTICS_START ] =
+ { "faceLandmarks", TYPE_INT32 },
+ [ ANDROID_STATISTICS_FACE_RECTANGLES - ANDROID_STATISTICS_START ] =
+ { "faceRectangles", TYPE_INT32 },
+ [ ANDROID_STATISTICS_FACE_SCORES - ANDROID_STATISTICS_START ] =
+ { "faceScores", TYPE_BYTE },
+ [ ANDROID_STATISTICS_HISTOGRAM - ANDROID_STATISTICS_START ] =
+ { "histogram", TYPE_INT32 },
+ [ ANDROID_STATISTICS_SHARPNESS_MAP - ANDROID_STATISTICS_START ] =
+ { "sharpnessMap", TYPE_INT32 },
+};
+
+static tag_info_t android_statistics_info[ANDROID_STATISTICS_INFO_END -
+ ANDROID_STATISTICS_INFO_START] = {
+ [ ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES - ANDROID_STATISTICS_INFO_START ] =
+ { "availableFaceDetectModes", TYPE_BYTE },
+ [ ANDROID_STATISTICS_INFO_HISTOGRAM_BUCKET_COUNT - ANDROID_STATISTICS_INFO_START ] =
+ { "histogramBucketCount", TYPE_INT32 },
+ [ ANDROID_STATISTICS_INFO_MAX_FACE_COUNT - ANDROID_STATISTICS_INFO_START ] =
+ { "maxFaceCount", TYPE_INT32 },
+ [ ANDROID_STATISTICS_INFO_MAX_HISTOGRAM_COUNT - ANDROID_STATISTICS_INFO_START ] =
+ { "maxHistogramCount", TYPE_INT32 },
+ [ ANDROID_STATISTICS_INFO_MAX_SHARPNESS_MAP_VALUE - ANDROID_STATISTICS_INFO_START ] =
+ { "maxSharpnessMapValue", TYPE_INT32 },
+ [ ANDROID_STATISTICS_INFO_SHARPNESS_MAP_SIZE - ANDROID_STATISTICS_INFO_START ] =
+ { "sharpnessMapSize", TYPE_INT32 },
+};
+
+static tag_info_t android_tonemap[ANDROID_TONEMAP_END -
+ ANDROID_TONEMAP_START] = {
+ [ ANDROID_TONEMAP_CURVE_BLUE - ANDROID_TONEMAP_START ] =
+ { "curveBlue", TYPE_FLOAT },
+ [ ANDROID_TONEMAP_CURVE_GREEN - ANDROID_TONEMAP_START ] =
+ { "curveGreen", TYPE_FLOAT },
+ [ ANDROID_TONEMAP_CURVE_RED - ANDROID_TONEMAP_START ] =
+ { "curveRed", TYPE_FLOAT },
+ [ ANDROID_TONEMAP_MODE - ANDROID_TONEMAP_START ] =
+ { "mode", TYPE_BYTE },
+ [ ANDROID_TONEMAP_MAX_CURVE_POINTS - ANDROID_TONEMAP_START ] =
+ { "maxCurvePoints", TYPE_INT32 },
+};
+
tag_info_t *tag_info[ANDROID_SECTION_COUNT] = {
- android_request,
- android_lens,
- android_lens_info,
- android_sensor,
- android_sensor_info,
+ android_color_correction,
+ android_control,
+ android_demosaic,
+ android_edge,
android_flash,
android_flash_info,
+ android_geometric,
android_hot_pixel,
android_hot_pixel_info,
- android_demosaic,
- android_demosaic_info,
- android_noise,
- android_noise_info,
- android_shading,
- android_shading_info,
- android_geometric,
- android_geometric_info,
- android_color,
- android_color_info,
- android_tonemap,
- android_tonemap_info,
- android_edge,
- android_edge_info,
- android_scaler,
- android_scaler_info,
android_jpeg,
- android_jpeg_info,
- android_stats,
- android_stats_info,
- android_control,
- android_control_info,
- android_quirks_info
+ android_lens,
+ android_lens_info,
+ android_noise_reduction,
+ android_quirks,
+ android_request,
+ android_scaler,
+ android_sensor,
+ android_sensor_info,
+ android_shading,
+ android_statistics,
+ android_statistics_info,
+ android_tonemap,
};
+
+int camera_metadata_enum_snprint(uint32_t tag,
+ uint32_t value,
+ char *dst,
+ size_t size) {
+ const char *msg = "error: not an enum";
+ int ret = -1;
+
+ switch(tag) {
+ case ANDROID_COLOR_CORRECTION_MODE: {
+ switch (value) {
+ case ANDROID_COLOR_CORRECTION_MODE_TRANSFORM_MATRIX:
+ msg = "TRANSFORM_MATRIX";
+ ret = 0;
+ break;
+ case ANDROID_COLOR_CORRECTION_MODE_FAST:
+ msg = "FAST";
+ ret = 0;
+ break;
+ case ANDROID_COLOR_CORRECTION_MODE_HIGH_QUALITY:
+ msg = "HIGH_QUALITY";
+ ret = 0;
+ break;
+ default:
+ msg = "error: enum value out of range";
+ }
+ break;
+ }
+ case ANDROID_COLOR_CORRECTION_TRANSFORM: {
+ break;
+ }
+
+ case ANDROID_CONTROL_AE_ANTIBANDING_MODE: {
+ switch (value) {
+ case ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF:
+ msg = "OFF";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_AE_ANTIBANDING_MODE_50HZ:
+ msg = "50HZ";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_AE_ANTIBANDING_MODE_60HZ:
+ msg = "60HZ";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO:
+ msg = "AUTO";
+ ret = 0;
+ break;
+ default:
+ msg = "error: enum value out of range";
+ }
+ break;
+ }
+ case ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION: {
+ break;
+ }
+ case ANDROID_CONTROL_AE_LOCK: {
+ switch (value) {
+ case ANDROID_CONTROL_AE_LOCK_OFF:
+ msg = "OFF";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_AE_LOCK_ON:
+ msg = "ON";
+ ret = 0;
+ break;
+ default:
+ msg = "error: enum value out of range";
+ }
+ break;
+ }
+ case ANDROID_CONTROL_AE_MODE: {
+ switch (value) {
+ case ANDROID_CONTROL_AE_MODE_OFF:
+ msg = "OFF";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_AE_MODE_ON:
+ msg = "ON";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH:
+ msg = "ON_AUTO_FLASH";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_AE_MODE_ON_ALWAYS_FLASH:
+ msg = "ON_ALWAYS_FLASH";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE:
+ msg = "ON_AUTO_FLASH_REDEYE";
+ ret = 0;
+ break;
+ default:
+ msg = "error: enum value out of range";
+ }
+ break;
+ }
+ case ANDROID_CONTROL_AE_REGIONS: {
+ break;
+ }
+ case ANDROID_CONTROL_AE_TARGET_FPS_RANGE: {
+ break;
+ }
+ case ANDROID_CONTROL_AF_MODE: {
+ switch (value) {
+ case ANDROID_CONTROL_AF_MODE_OFF:
+ msg = "OFF";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_AF_MODE_AUTO:
+ msg = "AUTO";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_AF_MODE_MACRO:
+ msg = "MACRO";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO:
+ msg = "CONTINUOUS_VIDEO";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE:
+ msg = "CONTINUOUS_PICTURE";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_AF_MODE_EDOF:
+ msg = "EDOF";
+ ret = 0;
+ break;
+ default:
+ msg = "error: enum value out of range";
+ }
+ break;
+ }
+ case ANDROID_CONTROL_AF_REGIONS: {
+ break;
+ }
+ case ANDROID_CONTROL_AWB_LOCK: {
+ switch (value) {
+ case ANDROID_CONTROL_AWB_LOCK_OFF:
+ msg = "OFF";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_AWB_LOCK_ON:
+ msg = "ON";
+ ret = 0;
+ break;
+ default:
+ msg = "error: enum value out of range";
+ }
+ break;
+ }
+ case ANDROID_CONTROL_AWB_MODE: {
+ switch (value) {
+ case ANDROID_CONTROL_AWB_MODE_OFF:
+ msg = "OFF";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_AWB_MODE_AUTO:
+ msg = "AUTO";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_AWB_MODE_INCANDESCENT:
+ msg = "INCANDESCENT";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_AWB_MODE_FLUORESCENT:
+ msg = "FLUORESCENT";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_AWB_MODE_WARM_FLUORESCENT:
+ msg = "WARM_FLUORESCENT";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_AWB_MODE_DAYLIGHT:
+ msg = "DAYLIGHT";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT:
+ msg = "CLOUDY_DAYLIGHT";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_AWB_MODE_TWILIGHT:
+ msg = "TWILIGHT";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_AWB_MODE_SHADE:
+ msg = "SHADE";
+ ret = 0;
+ break;
+ default:
+ msg = "error: enum value out of range";
+ }
+ break;
+ }
+ case ANDROID_CONTROL_AWB_REGIONS: {
+ break;
+ }
+ case ANDROID_CONTROL_CAPTURE_INTENT: {
+ switch (value) {
+ case ANDROID_CONTROL_CAPTURE_INTENT_CUSTOM:
+ msg = "CUSTOM";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW:
+ msg = "PREVIEW";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE:
+ msg = "STILL_CAPTURE";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_RECORD:
+ msg = "VIDEO_RECORD";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT:
+ msg = "VIDEO_SNAPSHOT";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_CAPTURE_INTENT_ZERO_SHUTTER_LAG:
+ msg = "ZERO_SHUTTER_LAG";
+ ret = 0;
+ break;
+ default:
+ msg = "error: enum value out of range";
+ }
+ break;
+ }
+ case ANDROID_CONTROL_EFFECT_MODE: {
+ switch (value) {
+ case ANDROID_CONTROL_EFFECT_MODE_OFF:
+ msg = "OFF";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_EFFECT_MODE_MONO:
+ msg = "MONO";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_EFFECT_MODE_NEGATIVE:
+ msg = "NEGATIVE";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_EFFECT_MODE_SOLARIZE:
+ msg = "SOLARIZE";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_EFFECT_MODE_SEPIA:
+ msg = "SEPIA";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_EFFECT_MODE_POSTERIZE:
+ msg = "POSTERIZE";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_EFFECT_MODE_WHITEBOARD:
+ msg = "WHITEBOARD";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_EFFECT_MODE_BLACKBOARD:
+ msg = "BLACKBOARD";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_EFFECT_MODE_AQUA:
+ msg = "AQUA";
+ ret = 0;
+ break;
+ default:
+ msg = "error: enum value out of range";
+ }
+ break;
+ }
+ case ANDROID_CONTROL_MODE: {
+ switch (value) {
+ case ANDROID_CONTROL_MODE_OFF:
+ msg = "OFF";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_MODE_AUTO:
+ msg = "AUTO";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_MODE_USE_SCENE_MODE:
+ msg = "USE_SCENE_MODE";
+ ret = 0;
+ break;
+ default:
+ msg = "error: enum value out of range";
+ }
+ break;
+ }
+ case ANDROID_CONTROL_SCENE_MODE: {
+ switch (value) {
+ case ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED:
+ msg = "UNSUPPORTED";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY:
+ msg = "FACE_PRIORITY";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_SCENE_MODE_ACTION:
+ msg = "ACTION";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_SCENE_MODE_PORTRAIT:
+ msg = "PORTRAIT";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_SCENE_MODE_LANDSCAPE:
+ msg = "LANDSCAPE";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_SCENE_MODE_NIGHT:
+ msg = "NIGHT";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT:
+ msg = "NIGHT_PORTRAIT";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_SCENE_MODE_THEATRE:
+ msg = "THEATRE";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_SCENE_MODE_BEACH:
+ msg = "BEACH";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_SCENE_MODE_SNOW:
+ msg = "SNOW";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_SCENE_MODE_SUNSET:
+ msg = "SUNSET";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO:
+ msg = "STEADYPHOTO";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_SCENE_MODE_FIREWORKS:
+ msg = "FIREWORKS";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_SCENE_MODE_SPORTS:
+ msg = "SPORTS";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_SCENE_MODE_PARTY:
+ msg = "PARTY";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT:
+ msg = "CANDLELIGHT";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_SCENE_MODE_BARCODE:
+ msg = "BARCODE";
+ ret = 0;
+ break;
+ default:
+ msg = "error: enum value out of range";
+ }
+ break;
+ }
+ case ANDROID_CONTROL_VIDEO_STABILIZATION_MODE: {
+ switch (value) {
+ case ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF:
+ msg = "OFF";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_ON:
+ msg = "ON";
+ ret = 0;
+ break;
+ default:
+ msg = "error: enum value out of range";
+ }
+ break;
+ }
+ case ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES: {
+ break;
+ }
+ case ANDROID_CONTROL_AE_AVAILABLE_MODES: {
+ break;
+ }
+ case ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES: {
+ break;
+ }
+ case ANDROID_CONTROL_AE_COMPENSATION_RANGE: {
+ break;
+ }
+ case ANDROID_CONTROL_AE_COMPENSATION_STEP: {
+ break;
+ }
+ case ANDROID_CONTROL_AF_AVAILABLE_MODES: {
+ break;
+ }
+ case ANDROID_CONTROL_AVAILABLE_EFFECTS: {
+ break;
+ }
+ case ANDROID_CONTROL_AVAILABLE_SCENE_MODES: {
+ break;
+ }
+ case ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES: {
+ break;
+ }
+ case ANDROID_CONTROL_AWB_AVAILABLE_MODES: {
+ break;
+ }
+ case ANDROID_CONTROL_MAX_REGIONS: {
+ break;
+ }
+ case ANDROID_CONTROL_SCENE_MODE_OVERRIDES: {
+ break;
+ }
+ case ANDROID_CONTROL_AE_PRECAPTURE_ID: {
+ break;
+ }
+ case ANDROID_CONTROL_AE_STATE: {
+ switch (value) {
+ case ANDROID_CONTROL_AE_STATE_INACTIVE:
+ msg = "INACTIVE";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_AE_STATE_SEARCHING:
+ msg = "SEARCHING";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_AE_STATE_CONVERGED:
+ msg = "CONVERGED";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_AE_STATE_LOCKED:
+ msg = "LOCKED";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_AE_STATE_FLASH_REQUIRED:
+ msg = "FLASH_REQUIRED";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_AE_STATE_PRECAPTURE:
+ msg = "PRECAPTURE";
+ ret = 0;
+ break;
+ default:
+ msg = "error: enum value out of range";
+ }
+ break;
+ }
+ case ANDROID_CONTROL_AF_STATE: {
+ switch (value) {
+ case ANDROID_CONTROL_AF_STATE_INACTIVE:
+ msg = "INACTIVE";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN:
+ msg = "PASSIVE_SCAN";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED:
+ msg = "PASSIVE_FOCUSED";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN:
+ msg = "ACTIVE_SCAN";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED:
+ msg = "FOCUSED_LOCKED";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED:
+ msg = "NOT_FOCUSED_LOCKED";
+ ret = 0;
+ break;
+ default:
+ msg = "error: enum value out of range";
+ }
+ break;
+ }
+ case ANDROID_CONTROL_AF_TRIGGER_ID: {
+ break;
+ }
+ case ANDROID_CONTROL_AWB_STATE: {
+ switch (value) {
+ case ANDROID_CONTROL_AWB_STATE_INACTIVE:
+ msg = "INACTIVE";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_AWB_STATE_SEARCHING:
+ msg = "SEARCHING";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_AWB_STATE_CONVERGED:
+ msg = "CONVERGED";
+ ret = 0;
+ break;
+ case ANDROID_CONTROL_AWB_STATE_LOCKED:
+ msg = "LOCKED";
+ ret = 0;
+ break;
+ default:
+ msg = "error: enum value out of range";
+ }
+ break;
+ }
+
+ case ANDROID_DEMOSAIC_MODE: {
+ switch (value) {
+ case ANDROID_DEMOSAIC_MODE_FAST:
+ msg = "FAST";
+ ret = 0;
+ break;
+ case ANDROID_DEMOSAIC_MODE_HIGH_QUALITY:
+ msg = "HIGH_QUALITY";
+ ret = 0;
+ break;
+ default:
+ msg = "error: enum value out of range";
+ }
+ break;
+ }
+
+ case ANDROID_EDGE_MODE: {
+ switch (value) {
+ case ANDROID_EDGE_MODE_OFF:
+ msg = "OFF";
+ ret = 0;
+ break;
+ case ANDROID_EDGE_MODE_FAST:
+ msg = "FAST";
+ ret = 0;
+ break;
+ case ANDROID_EDGE_MODE_HIGH_QUALITY:
+ msg = "HIGH_QUALITY";
+ ret = 0;
+ break;
+ default:
+ msg = "error: enum value out of range";
+ }
+ break;
+ }
+ case ANDROID_EDGE_STRENGTH: {
+ break;
+ }
+
+ case ANDROID_FLASH_FIRING_POWER: {
+ break;
+ }
+ case ANDROID_FLASH_FIRING_TIME: {
+ break;
+ }
+ case ANDROID_FLASH_MODE: {
+ switch (value) {
+ case ANDROID_FLASH_MODE_OFF:
+ msg = "OFF";
+ ret = 0;
+ break;
+ case ANDROID_FLASH_MODE_SINGLE:
+ msg = "SINGLE";
+ ret = 0;
+ break;
+ case ANDROID_FLASH_MODE_TORCH:
+ msg = "TORCH";
+ ret = 0;
+ break;
+ default:
+ msg = "error: enum value out of range";
+ }
+ break;
+ }
+ case ANDROID_FLASH_COLOR_TEMPERATURE: {
+ break;
+ }
+ case ANDROID_FLASH_MAX_ENERGY: {
+ break;
+ }
+ case ANDROID_FLASH_STATE: {
+ switch (value) {
+ case ANDROID_FLASH_STATE_UNAVAILABLE:
+ msg = "UNAVAILABLE";
+ ret = 0;
+ break;
+ case ANDROID_FLASH_STATE_CHARGING:
+ msg = "CHARGING";
+ ret = 0;
+ break;
+ case ANDROID_FLASH_STATE_READY:
+ msg = "READY";
+ ret = 0;
+ break;
+ case ANDROID_FLASH_STATE_FIRED:
+ msg = "FIRED";
+ ret = 0;
+ break;
+ default:
+ msg = "error: enum value out of range";
+ }
+ break;
+ }
+
+ case ANDROID_FLASH_INFO_AVAILABLE: {
+ break;
+ }
+ case ANDROID_FLASH_INFO_CHARGE_DURATION: {
+ break;
+ }
+
+ case ANDROID_GEOMETRIC_MODE: {
+ switch (value) {
+ case ANDROID_GEOMETRIC_MODE_OFF:
+ msg = "OFF";
+ ret = 0;
+ break;
+ case ANDROID_GEOMETRIC_MODE_FAST:
+ msg = "FAST";
+ ret = 0;
+ break;
+ case ANDROID_GEOMETRIC_MODE_HIGH_QUALITY:
+ msg = "HIGH_QUALITY";
+ ret = 0;
+ break;
+ default:
+ msg = "error: enum value out of range";
+ }
+ break;
+ }
+ case ANDROID_GEOMETRIC_STRENGTH: {
+ break;
+ }
+
+ case ANDROID_HOT_PIXEL_MODE: {
+ switch (value) {
+ case ANDROID_HOT_PIXEL_MODE_OFF:
+ msg = "OFF";
+ ret = 0;
+ break;
+ case ANDROID_HOT_PIXEL_MODE_FAST:
+ msg = "FAST";
+ ret = 0;
+ break;
+ case ANDROID_HOT_PIXEL_MODE_HIGH_QUALITY:
+ msg = "HIGH_QUALITY";
+ ret = 0;
+ break;
+ default:
+ msg = "error: enum value out of range";
+ }
+ break;
+ }
+
+ case ANDROID_HOT_PIXEL_INFO_MAP: {
+ break;
+ }
+
+ case ANDROID_JPEG_GPS_COORDINATES: {
+ break;
+ }
+ case ANDROID_JPEG_GPS_PROCESSING_METHOD: {
+ break;
+ }
+ case ANDROID_JPEG_GPS_TIMESTAMP: {
+ break;
+ }
+ case ANDROID_JPEG_ORIENTATION: {
+ break;
+ }
+ case ANDROID_JPEG_QUALITY: {
+ break;
+ }
+ case ANDROID_JPEG_THUMBNAIL_QUALITY: {
+ break;
+ }
+ case ANDROID_JPEG_THUMBNAIL_SIZE: {
+ break;
+ }
+ case ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES: {
+ break;
+ }
+ case ANDROID_JPEG_MAX_SIZE: {
+ break;
+ }
+ case ANDROID_JPEG_SIZE: {
+ break;
+ }
+
+ case ANDROID_LENS_APERTURE: {
+ break;
+ }
+ case ANDROID_LENS_FILTER_DENSITY: {
+ break;
+ }
+ case ANDROID_LENS_FOCAL_LENGTH: {
+ break;
+ }
+ case ANDROID_LENS_FOCUS_DISTANCE: {
+ break;
+ }
+ case ANDROID_LENS_OPTICAL_STABILIZATION_MODE: {
+ switch (value) {
+ case ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF:
+ msg = "OFF";
+ ret = 0;
+ break;
+ case ANDROID_LENS_OPTICAL_STABILIZATION_MODE_ON:
+ msg = "ON";
+ ret = 0;
+ break;
+ default:
+ msg = "error: enum value out of range";
+ }
+ break;
+ }
+ case ANDROID_LENS_FACING: {
+ switch (value) {
+ case ANDROID_LENS_FACING_FRONT:
+ msg = "FRONT";
+ ret = 0;
+ break;
+ case ANDROID_LENS_FACING_BACK:
+ msg = "BACK";
+ ret = 0;
+ break;
+ default:
+ msg = "error: enum value out of range";
+ }
+ break;
+ }
+ case ANDROID_LENS_OPTICAL_AXIS_ANGLE: {
+ break;
+ }
+ case ANDROID_LENS_POSITION: {
+ break;
+ }
+ case ANDROID_LENS_FOCUS_RANGE: {
+ break;
+ }
+ case ANDROID_LENS_STATE: {
+ switch (value) {
+ case ANDROID_LENS_STATE_STATIONARY:
+ msg = "STATIONARY";
+ ret = 0;
+ break;
+ default:
+ msg = "error: enum value out of range";
+ }
+ break;
+ }
+
+ case ANDROID_LENS_INFO_AVAILABLE_APERTURES: {
+ break;
+ }
+ case ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES: {
+ break;
+ }
+ case ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS: {
+ break;
+ }
+ case ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION: {
+ break;
+ }
+ case ANDROID_LENS_INFO_GEOMETRIC_CORRECTION_MAP: {
+ break;
+ }
+ case ANDROID_LENS_INFO_GEOMETRIC_CORRECTION_MAP_SIZE: {
+ break;
+ }
+ case ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE: {
+ break;
+ }
+ case ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE: {
+ break;
+ }
+ case ANDROID_LENS_INFO_SHADING_MAP: {
+ break;
+ }
+ case ANDROID_LENS_INFO_SHADING_MAP_SIZE: {
+ break;
+ }
+
+ case ANDROID_NOISE_REDUCTION_MODE: {
+ switch (value) {
+ case ANDROID_NOISE_REDUCTION_MODE_OFF:
+ msg = "OFF";
+ ret = 0;
+ break;
+ case ANDROID_NOISE_REDUCTION_MODE_FAST:
+ msg = "FAST";
+ ret = 0;
+ break;
+ case ANDROID_NOISE_REDUCTION_MODE_HIGH_QUALITY:
+ msg = "HIGH_QUALITY";
+ ret = 0;
+ break;
+ default:
+ msg = "error: enum value out of range";
+ }
+ break;
+ }
+ case ANDROID_NOISE_REDUCTION_STRENGTH: {
+ break;
+ }
+
+ case ANDROID_QUIRKS_METERING_CROP_REGION: {
+ break;
+ }
+ case ANDROID_QUIRKS_TRIGGER_AF_WITH_AUTO: {
+ break;
+ }
+ case ANDROID_QUIRKS_USE_ZSL_FORMAT: {
+ break;
+ }
+
+ case ANDROID_REQUEST_FRAME_COUNT: {
+ break;
+ }
+ case ANDROID_REQUEST_ID: {
+ break;
+ }
+ case ANDROID_REQUEST_INPUT_STREAMS: {
+ break;
+ }
+ case ANDROID_REQUEST_METADATA_MODE: {
+ switch (value) {
+ case ANDROID_REQUEST_METADATA_MODE_NONE:
+ msg = "NONE";
+ ret = 0;
+ break;
+ case ANDROID_REQUEST_METADATA_MODE_FULL:
+ msg = "FULL";
+ ret = 0;
+ break;
+ default:
+ msg = "error: enum value out of range";
+ }
+ break;
+ }
+ case ANDROID_REQUEST_OUTPUT_STREAMS: {
+ break;
+ }
+ case ANDROID_REQUEST_TYPE: {
+ switch (value) {
+ case ANDROID_REQUEST_TYPE_CAPTURE:
+ msg = "CAPTURE";
+ ret = 0;
+ break;
+ case ANDROID_REQUEST_TYPE_REPROCESS:
+ msg = "REPROCESS";
+ ret = 0;
+ break;
+ default:
+ msg = "error: enum value out of range";
+ }
+ break;
+ }
+ case ANDROID_REQUEST_MAX_NUM_OUTPUT_STREAMS: {
+ break;
+ }
+ case ANDROID_REQUEST_MAX_NUM_REPROCESS_STREAMS: {
+ break;
+ }
+
+ case ANDROID_SCALER_CROP_REGION: {
+ break;
+ }
+ case ANDROID_SCALER_AVAILABLE_FORMATS: {
+ switch (value) {
+ case ANDROID_SCALER_AVAILABLE_FORMATS_RAW_SENSOR:
+ msg = "RAW_SENSOR";
+ ret = 0;
+ break;
+ case ANDROID_SCALER_AVAILABLE_FORMATS_YV12:
+ msg = "YV12";
+ ret = 0;
+ break;
+ case ANDROID_SCALER_AVAILABLE_FORMATS_YCbCr_420_SP:
+ msg = "YCbCr_420_SP";
+ ret = 0;
+ break;
+ case ANDROID_SCALER_AVAILABLE_FORMATS_JPEG:
+ msg = "JPEG";
+ ret = 0;
+ break;
+ default:
+ msg = "error: enum value out of range";
+ }
+ break;
+ }
+ case ANDROID_SCALER_AVAILABLE_JPEG_MIN_DURATIONS: {
+ break;
+ }
+ case ANDROID_SCALER_AVAILABLE_JPEG_SIZES: {
+ break;
+ }
+ case ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM: {
+ break;
+ }
+ case ANDROID_SCALER_AVAILABLE_PROCESSED_MIN_DURATIONS: {
+ break;
+ }
+ case ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES: {
+ break;
+ }
+ case ANDROID_SCALER_AVAILABLE_RAW_MIN_DURATIONS: {
+ break;
+ }
+ case ANDROID_SCALER_AVAILABLE_RAW_SIZES: {
+ break;
+ }
+ case ANDROID_SCALER_MAX_DIGITAL_ZOOM: {
+ break;
+ }
+
+ case ANDROID_SENSOR_EXPOSURE_TIME: {
+ break;
+ }
+ case ANDROID_SENSOR_FRAME_DURATION: {
+ break;
+ }
+ case ANDROID_SENSOR_SENSITIVITY: {
+ break;
+ }
+ case ANDROID_SENSOR_BASE_GAIN_FACTOR: {
+ break;
+ }
+ case ANDROID_SENSOR_BLACK_LEVEL_PATTERN: {
+ break;
+ }
+ case ANDROID_SENSOR_CALIBRATION_TRANSFORM1: {
+ break;
+ }
+ case ANDROID_SENSOR_CALIBRATION_TRANSFORM2: {
+ break;
+ }
+ case ANDROID_SENSOR_COLOR_TRANSFORM1: {
+ break;
+ }
+ case ANDROID_SENSOR_COLOR_TRANSFORM2: {
+ break;
+ }
+ case ANDROID_SENSOR_FORWARD_MATRIX1: {
+ break;
+ }
+ case ANDROID_SENSOR_FORWARD_MATRIX2: {
+ break;
+ }
+ case ANDROID_SENSOR_MAX_ANALOG_SENSITIVITY: {
+ break;
+ }
+ case ANDROID_SENSOR_NOISE_MODEL_COEFFICIENTS: {
+ break;
+ }
+ case ANDROID_SENSOR_ORIENTATION: {
+ break;
+ }
+ case ANDROID_SENSOR_REFERENCE_ILLUMINANT1: {
+ switch (value) {
+ case ANDROID_SENSOR_REFERENCE_ILLUMINANT1_DAYLIGHT:
+ msg = "DAYLIGHT";
+ ret = 0;
+ break;
+ case ANDROID_SENSOR_REFERENCE_ILLUMINANT1_FLUORESCENT:
+ msg = "FLUORESCENT";
+ ret = 0;
+ break;
+ case ANDROID_SENSOR_REFERENCE_ILLUMINANT1_TUNGSTEN:
+ msg = "TUNGSTEN";
+ ret = 0;
+ break;
+ case ANDROID_SENSOR_REFERENCE_ILLUMINANT1_FLASH:
+ msg = "FLASH";
+ ret = 0;
+ break;
+ case ANDROID_SENSOR_REFERENCE_ILLUMINANT1_FINE_WEATHER:
+ msg = "FINE_WEATHER";
+ ret = 0;
+ break;
+ case ANDROID_SENSOR_REFERENCE_ILLUMINANT1_CLOUDY_WEATHER:
+ msg = "CLOUDY_WEATHER";
+ ret = 0;
+ break;
+ case ANDROID_SENSOR_REFERENCE_ILLUMINANT1_SHADE:
+ msg = "SHADE";
+ ret = 0;
+ break;
+ case ANDROID_SENSOR_REFERENCE_ILLUMINANT1_DAYLIGHT_FLUORESCENT:
+ msg = "DAYLIGHT_FLUORESCENT";
+ ret = 0;
+ break;
+ case ANDROID_SENSOR_REFERENCE_ILLUMINANT1_DAY_WHITE_FLUORESCENT:
+ msg = "DAY_WHITE_FLUORESCENT";
+ ret = 0;
+ break;
+ case ANDROID_SENSOR_REFERENCE_ILLUMINANT1_COOL_WHITE_FLUORESCENT:
+ msg = "COOL_WHITE_FLUORESCENT";
+ ret = 0;
+ break;
+ case ANDROID_SENSOR_REFERENCE_ILLUMINANT1_WHITE_FLUORESCENT:
+ msg = "WHITE_FLUORESCENT";
+ ret = 0;
+ break;
+ case ANDROID_SENSOR_REFERENCE_ILLUMINANT1_STANDARD_A:
+ msg = "STANDARD_A";
+ ret = 0;
+ break;
+ case ANDROID_SENSOR_REFERENCE_ILLUMINANT1_STANDARD_B:
+ msg = "STANDARD_B";
+ ret = 0;
+ break;
+ case ANDROID_SENSOR_REFERENCE_ILLUMINANT1_STANDARD_C:
+ msg = "STANDARD_C";
+ ret = 0;
+ break;
+ case ANDROID_SENSOR_REFERENCE_ILLUMINANT1_D55:
+ msg = "D55";
+ ret = 0;
+ break;
+ case ANDROID_SENSOR_REFERENCE_ILLUMINANT1_D65:
+ msg = "D65";
+ ret = 0;
+ break;
+ case ANDROID_SENSOR_REFERENCE_ILLUMINANT1_D75:
+ msg = "D75";
+ ret = 0;
+ break;
+ case ANDROID_SENSOR_REFERENCE_ILLUMINANT1_D50:
+ msg = "D50";
+ ret = 0;
+ break;
+ case ANDROID_SENSOR_REFERENCE_ILLUMINANT1_ISO_STUDIO_TUNGSTEN:
+ msg = "ISO_STUDIO_TUNGSTEN";
+ ret = 0;
+ break;
+ default:
+ msg = "error: enum value out of range";
+ }
+ break;
+ }
+ case ANDROID_SENSOR_REFERENCE_ILLUMINANT2: {
+ break;
+ }
+ case ANDROID_SENSOR_TIMESTAMP: {
+ break;
+ }
+
+ case ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE: {
+ break;
+ }
+ case ANDROID_SENSOR_INFO_AVAILABLE_SENSITIVITIES: {
+ break;
+ }
+ case ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT: {
+ switch (value) {
+ case ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_RGGB:
+ msg = "RGGB";
+ ret = 0;
+ break;
+ case ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_GRBG:
+ msg = "GRBG";
+ ret = 0;
+ break;
+ case ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_GBRG:
+ msg = "GBRG";
+ ret = 0;
+ break;
+ case ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_BGGR:
+ msg = "BGGR";
+ ret = 0;
+ break;
+ case ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_RGB:
+ msg = "RGB";
+ ret = 0;
+ break;
+ default:
+ msg = "error: enum value out of range";
+ }
+ break;
+ }
+ case ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE: {
+ break;
+ }
+ case ANDROID_SENSOR_INFO_MAX_FRAME_DURATION: {
+ break;
+ }
+ case ANDROID_SENSOR_INFO_PHYSICAL_SIZE: {
+ break;
+ }
+ case ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE: {
+ break;
+ }
+ case ANDROID_SENSOR_INFO_WHITE_LEVEL: {
+ break;
+ }
+
+ case ANDROID_SHADING_MODE: {
+ switch (value) {
+ case ANDROID_SHADING_MODE_OFF:
+ msg = "OFF";
+ ret = 0;
+ break;
+ case ANDROID_SHADING_MODE_FAST:
+ msg = "FAST";
+ ret = 0;
+ break;
+ case ANDROID_SHADING_MODE_HIGH_QUALITY:
+ msg = "HIGH_QUALITY";
+ ret = 0;
+ break;
+ default:
+ msg = "error: enum value out of range";
+ }
+ break;
+ }
+ case ANDROID_SHADING_STRENGTH: {
+ break;
+ }
+
+ case ANDROID_STATISTICS_FACE_DETECT_MODE: {
+ switch (value) {
+ case ANDROID_STATISTICS_FACE_DETECT_MODE_OFF:
+ msg = "OFF";
+ ret = 0;
+ break;
+ case ANDROID_STATISTICS_FACE_DETECT_MODE_SIMPLE:
+ msg = "SIMPLE";
+ ret = 0;
+ break;
+ case ANDROID_STATISTICS_FACE_DETECT_MODE_FULL:
+ msg = "FULL";
+ ret = 0;
+ break;
+ default:
+ msg = "error: enum value out of range";
+ }
+ break;
+ }
+ case ANDROID_STATISTICS_HISTOGRAM_MODE: {
+ switch (value) {
+ case ANDROID_STATISTICS_HISTOGRAM_MODE_OFF:
+ msg = "OFF";
+ ret = 0;
+ break;
+ case ANDROID_STATISTICS_HISTOGRAM_MODE_ON:
+ msg = "ON";
+ ret = 0;
+ break;
+ default:
+ msg = "error: enum value out of range";
+ }
+ break;
+ }
+ case ANDROID_STATISTICS_SHARPNESS_MAP_MODE: {
+ switch (value) {
+ case ANDROID_STATISTICS_SHARPNESS_MAP_MODE_OFF:
+ msg = "OFF";
+ ret = 0;
+ break;
+ case ANDROID_STATISTICS_SHARPNESS_MAP_MODE_ON:
+ msg = "ON";
+ ret = 0;
+ break;
+ default:
+ msg = "error: enum value out of range";
+ }
+ break;
+ }
+ case ANDROID_STATISTICS_FACE_IDS: {
+ break;
+ }
+ case ANDROID_STATISTICS_FACE_LANDMARKS: {
+ break;
+ }
+ case ANDROID_STATISTICS_FACE_RECTANGLES: {
+ break;
+ }
+ case ANDROID_STATISTICS_FACE_SCORES: {
+ break;
+ }
+ case ANDROID_STATISTICS_HISTOGRAM: {
+ break;
+ }
+ case ANDROID_STATISTICS_SHARPNESS_MAP: {
+ break;
+ }
+
+ case ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES: {
+ break;
+ }
+ case ANDROID_STATISTICS_INFO_HISTOGRAM_BUCKET_COUNT: {
+ break;
+ }
+ case ANDROID_STATISTICS_INFO_MAX_FACE_COUNT: {
+ break;
+ }
+ case ANDROID_STATISTICS_INFO_MAX_HISTOGRAM_COUNT: {
+ break;
+ }
+ case ANDROID_STATISTICS_INFO_MAX_SHARPNESS_MAP_VALUE: {
+ break;
+ }
+ case ANDROID_STATISTICS_INFO_SHARPNESS_MAP_SIZE: {
+ break;
+ }
+
+ case ANDROID_TONEMAP_CURVE_BLUE: {
+ break;
+ }
+ case ANDROID_TONEMAP_CURVE_GREEN: {
+ break;
+ }
+ case ANDROID_TONEMAP_CURVE_RED: {
+ break;
+ }
+ case ANDROID_TONEMAP_MODE: {
+ switch (value) {
+ case ANDROID_TONEMAP_MODE_CONTRAST_CURVE:
+ msg = "CONTRAST_CURVE";
+ ret = 0;
+ break;
+ case ANDROID_TONEMAP_MODE_FAST:
+ msg = "FAST";
+ ret = 0;
+ break;
+ case ANDROID_TONEMAP_MODE_HIGH_QUALITY:
+ msg = "HIGH_QUALITY";
+ ret = 0;
+ break;
+ default:
+ msg = "error: enum value out of range";
+ }
+ break;
+ }
+ case ANDROID_TONEMAP_MAX_CURVE_POINTS: {
+ break;
+ }
+
+ }
+
+ strncpy(dst, msg, size - 1);
+ dst[size - 1] = '\0';
+
+ return ret;
+}
+
+
+#define CAMERA_METADATA_ENUM_STRING_MAX_SIZE 23
diff --git a/camera/tests/camera_metadata_tests.cpp b/camera/tests/camera_metadata_tests.cpp
index 47faf42..4712121 100644
--- a/camera/tests/camera_metadata_tests.cpp
+++ b/camera/tests/camera_metadata_tests.cpp
@@ -20,6 +20,8 @@
#include <errno.h>
+#include <vector>
+#include <algorithm>
#include "gtest/gtest.h"
#include "system/camera_metadata.h"
@@ -226,11 +228,11 @@
0.0f, 0.1f, 0.7f
};
result = add_camera_metadata_entry(m,
- ANDROID_COLOR_TRANSFORM,
+ ANDROID_COLOR_CORRECTION_TRANSFORM,
colorTransform, 9);
EXPECT_EQ(OK, result);
data_used += calculate_camera_metadata_entry_data_size(
- get_camera_metadata_tag_type(ANDROID_COLOR_TRANSFORM), 9);
+ get_camera_metadata_tag_type(ANDROID_COLOR_CORRECTION_TRANSFORM), 9);
entries_used++;
// Check added entries
@@ -267,7 +269,7 @@
3, &entry);
EXPECT_EQ(OK, result);
EXPECT_EQ((size_t)3, entry.index);
- EXPECT_EQ(ANDROID_COLOR_TRANSFORM, entry.tag);
+ EXPECT_EQ(ANDROID_COLOR_CORRECTION_TRANSFORM, entry.tag);
EXPECT_EQ(TYPE_FLOAT, entry.type);
EXPECT_EQ((size_t)9, entry.count);
for (unsigned int i=0; i < entry.count; i++) {
@@ -881,7 +883,7 @@
0.0f, 0.1f, 0.7f
};
result = add_camera_metadata_entry(m,
- ANDROID_COLOR_TRANSFORM,
+ ANDROID_COLOR_CORRECTION_TRANSFORM,
colorTransform, 9);
EXPECT_EQ(OK, result);
@@ -916,7 +918,7 @@
EXPECT_EQ(focus_distance, *entry.data.f);
result = find_camera_metadata_entry(m,
- ANDROID_NOISE_STRENGTH,
+ ANDROID_NOISE_REDUCTION_STRENGTH,
&entry);
EXPECT_EQ(NOT_FOUND, result);
EXPECT_EQ((size_t)1, entry.index);
@@ -940,22 +942,35 @@
}
// Test sorted find
+ size_t lensFocusIndex = -1;
+ {
+ std::vector<uint32_t> tags;
+ tags.push_back(ANDROID_COLOR_CORRECTION_TRANSFORM);
+ tags.push_back(ANDROID_LENS_FOCUS_DISTANCE);
+ tags.push_back(ANDROID_SENSOR_EXPOSURE_TIME);
+ tags.push_back(ANDROID_SENSOR_SENSITIVITY);
+ std::sort(tags.begin(), tags.end());
+
+ lensFocusIndex =
+ std::find(tags.begin(), tags.end(), ANDROID_LENS_FOCUS_DISTANCE)
+ - tags.begin();
+ }
result = find_camera_metadata_entry(m,
ANDROID_LENS_FOCUS_DISTANCE,
&entry);
EXPECT_EQ(OK, result);
- EXPECT_EQ((size_t)0, entry.index);
+ EXPECT_EQ(lensFocusIndex, entry.index);
EXPECT_EQ(ANDROID_LENS_FOCUS_DISTANCE, entry.tag);
EXPECT_EQ(TYPE_FLOAT, entry.type);
EXPECT_EQ((size_t)1, (size_t)entry.count);
EXPECT_EQ(focus_distance, *entry.data.f);
result = find_camera_metadata_entry(m,
- ANDROID_NOISE_STRENGTH,
+ ANDROID_NOISE_REDUCTION_STRENGTH,
&entry);
EXPECT_EQ(NOT_FOUND, result);
- EXPECT_EQ((size_t)0, entry.index);
+ EXPECT_EQ(lensFocusIndex, entry.index);
EXPECT_EQ(ANDROID_LENS_FOCUS_DISTANCE, entry.tag);
EXPECT_EQ(TYPE_FLOAT, entry.type);
EXPECT_EQ((size_t)1, entry.count);
@@ -1751,7 +1766,7 @@
ANDROID_LENS_FOCUS_DISTANCE,
ANDROID_SENSOR_EXPOSURE_TIME,
ANDROID_JPEG_GPS_COORDINATES,
- ANDROID_CONTROL_AE_EXP_COMPENSATION_STEP
+ ANDROID_CONTROL_AE_COMPENSATION_STEP
};
/*
