am ca9e6549: (-s ours) Camera2: Prepare to generate tags from script: DO NOT MERGE
# Via Igor Murashkin
* commit 'ca9e65498b00c26575209012b7da0b50a170f47e':
Camera2: Prepare to generate tags from script: 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
index b3cf0ce..3cdae4d 100644
--- a/camera/docs/README.md
+++ b/camera/docs/README.md
@@ -6,8 +6,21 @@
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:
-sudo apt-get install python-mako # mako templates. needed to do file generation
-sudo apt-get install python-bs4 # beautiful soup. needed to parse the xml
-sudo apt-get install tidy # tidy, used to clean up xml/html
-sudo apt-get install xmllint # xmllint, used to validate XML against XSD
+## 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
index bceadc1..bfe5d86 100644
--- a/camera/docs/camera_metadata_tag_info.mako
+++ b/camera/docs/camera_metadata_tag_info.mako
@@ -49,11 +49,7 @@
${path_name(sec) | csym}_START] = {
% for entry in find_unique_entries(sec):
[ ${entry.name | csym} - ${path_name(sec) | csym}_START ] =
- % if entry.name == "android.scaler.availableFormats": #FIXME: support enums separately from the data type?
- { ${'"%s",' %(entry.name_short) | pad(40)} ${"int32" | ctype_enum,ljust(11)} },
- % else:
{ ${'"%s",' %(entry.name_short) | pad(40)} ${entry.type | ctype_enum,ljust(11)} },
- % endif
% endfor
};
@@ -76,7 +72,7 @@
% for sec in find_all_sections(metadata):
% for idx,entry in enumerate(find_unique_entries(sec)):
case ${entry.name | csym}: {
- % if entry.type == 'enum':
+ % if entry.enum:
switch (value) {
% for val in entry.enum.values:
case ${entry.name | csym}_${val.name}:
@@ -101,3 +97,9 @@
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
index 275510d..d7a5564 100644
--- a/camera/docs/camera_metadata_tags.mako
+++ b/camera/docs/camera_metadata_tags.mako
@@ -81,7 +81,7 @@
% for sec in find_all_sections(metadata):
% for entry in find_unique_entries(sec):
- % if entry.type == 'enum':
+ % if entry.enum:
// ${entry.name | csym}
typedef enum camera_metadata_enum_${csym(entry.name).lower()} {
% for val in entry.enum.values:
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 c29859e..0baf181 100644
--- a/camera/docs/html.mako
+++ b/camera/docs/html.mako
@@ -42,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:" = " }
@@ -136,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>
@@ -184,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
@@ -205,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>
@@ -251,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
index bf3e3ee..7869763 100755
--- a/camera/docs/metadata-generate
+++ b/camera/docs/metadata-generate
@@ -25,14 +25,29 @@
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
- $thisdir/metadata_parser_xml.py $thisdir/metadata_properties.xml $in > $out
- return $?
+ 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
diff --git a/camera/docs/metadata-parser-sanity-check b/camera/docs/metadata-parser-sanity-check
index 940300c..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 || exit 1
+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
index 1a01dff..fd09d98 100644
--- a/camera/docs/metadata_helpers.py
+++ b/camera/docs/metadata_helpers.py
@@ -19,6 +19,7 @@
"""
import metadata_model
+from collections import OrderedDict
_context_buf = None
@@ -76,7 +77,7 @@
not isinstance(node, metadata_model.InnerNamespace):
raise TypeError("expected node to be a Section or InnerNamespace")
- d = {}
+ 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 \
@@ -234,12 +235,9 @@
ctype_enum('int32') == 'TYPE_INT32'
ctype_enum('int64') == 'TYPE_INT64'
ctype_enum('float') == 'TYPE_FLOAT'
- ctype_enum('enum') == 'TYPE_BYTE'
Remarks:
An enum is coerced to a byte since the rest of the camera_metadata
code doesn't support enums directly yet.
"""
- if what == 'enum':
- return 'TYPE_BYTE'
return 'TYPE_%s' %(what.upper())
diff --git a/camera/docs/metadata_model.py b/camera/docs/metadata_model.py
index 1acf2b5..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)
@@ -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
@@ -1065,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.
@@ -1132,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 a9ee25f..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
@@ -107,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()
@@ -144,7 +146,7 @@
#
# Enum
#
- if entry['type'] == 'enum':
+ if entry.get('enum', 'false') == 'true':
enum_values = []
enum_optionals = []
@@ -169,6 +171,7 @@
d['enum_optionals'] = enum_optionals
d['enum_notes'] = enum_notes
d['enum_ids'] = enum_ids
+ d['enum'] = True
#
# Container (Array/Tuple)
@@ -250,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 3bca091..d0a1d33 100644
--- a/camera/docs/metadata_properties.xml
+++ b/camera/docs/metadata_properties.xml
@@ -40,7 +40,7 @@
<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
@@ -82,7 +82,7 @@
</section>
<section name="control">
<controls>
- <entry name="aeAntibandingMode" type="enum">
+ <entry name="aeAntibandingMode" type="byte" enum="true">
<enum>
<value>OFF</value>
<value>50HZ</value>
@@ -103,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>
@@ -120,7 +120,7 @@
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
@@ -187,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;
@@ -277,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>
@@ -295,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>
@@ -336,7 +336,7 @@
in the frame metadata</notes>
<tag id="BC" />
</entry>
- <entry name="captureIntent" type="enum">
+ <entry name="captureIntent" type="byte" enum="true">
<enum>
<value>CUSTOM
<notes>This request doesn't fall into the other
@@ -368,7 +368,7 @@
<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>OFF</value>
<value optional="true">MONO</value>
@@ -385,7 +385,7 @@
<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
@@ -410,7 +410,7 @@
<range>all must be supported</range>
<tag id="BC" />
</entry>
- <entry name="sceneMode" type="enum">
+ <entry name="sceneMode" type="byte" enum="true">
<enum>
<value id="0">UNSUPPORTED</value>
<value>FACE_PRIORITY
@@ -443,7 +443,7 @@
<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>
@@ -601,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>
@@ -635,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
@@ -677,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>
@@ -702,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
@@ -719,7 +719,7 @@
</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>
@@ -763,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
@@ -822,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>
@@ -843,7 +843,7 @@
</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
@@ -869,7 +869,7 @@
</section>
<section name="hotPixel">
<controls>
- <entry name="mode" type="enum">
+ <entry name="mode" type="byte" enum="true">
<enum>
<value>OFF
<notes>No hot pixel correction can be
@@ -1050,7 +1050,7 @@
<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>
@@ -1192,7 +1192,7 @@
<tag id="V1" />
</entry>
</namespace>
- <entry name="facing" type="enum">
+ <entry name="facing" type="byte" enum="true">
<enum>
<value>FRONT</value>
<value>BACK</value>
@@ -1256,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>
@@ -1267,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>
@@ -1362,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
@@ -1392,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,
@@ -1473,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>
@@ -1652,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>
@@ -1844,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>
@@ -1904,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>
@@ -1933,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
@@ -1949,7 +1949,7 @@
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>
@@ -1958,7 +1958,7 @@
generation</description>
<tag id="V1" />
</entry>
- <entry name="sharpnessMapMode" type="enum">
+ <entry name="sharpnessMapMode" type="byte" enum="true">
<enum>
<value>OFF</value>
<value>ON</value>
@@ -2092,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>
@@ -2123,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
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 84ac43d..253db61 100644
--- a/camera/docs/metadata_template.mako
+++ b/camera/docs/metadata_template.mako
@@ -72,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
@@ -93,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
};
/*
