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
new file mode 100644
index 0000000..bfe5d86
--- /dev/null
+++ b/camera/docs/camera_metadata_tag_info.mako
@@ -0,0 +1,105 @@
+## -*- coding: utf-8 -*-
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * !! Do not reference this file directly !!
+ *
+ * It is logically a part of camera_metadata.c.  It is broken out for ease of
+ * maintaining the tag info.
+ *
+ * Array assignments are done using specified-index syntax to keep things in
+ * sync with camera_metadata_tags.h
+ */
+
+/**
+ * ! Do not edit this file directly !
+ *
+ * Generated automatically from camera_metadata_tag_info.mako
+ */
+
+const char *camera_metadata_section_names[ANDROID_SECTION_COUNT] = {
+  % for i in find_all_sections(metadata):
+    ${"[%s]" %(path_name(i)) | csym,pad(36)} = "${path_name(i)}",
+  % endfor
+};
+
+unsigned int camera_metadata_section_bounds[ANDROID_SECTION_COUNT][2] = {
+  % for i in find_all_sections(metadata):
+    ${"[%s]" %(path_name(i)) | csym,pad(36)} = { ${path_name(i) | csym}_START,
+                                       ${path_name(i) | csym}_END },
+  % endfor
+};
+
+% for sec in find_all_sections(metadata):
+static tag_info_t ${path_name(sec) | csyml}[${path_name(sec) | csym}_END -
+        ${path_name(sec) | csym}_START] = {
+  % for entry in find_unique_entries(sec):
+    [ ${entry.name | csym} - ${path_name(sec) | csym}_START ] =
+    { ${'"%s",' %(entry.name_short) | pad(40)} ${entry.type | ctype_enum,ljust(11)} },
+  % endfor
+};
+
+% endfor
+
+tag_info_t *tag_info[ANDROID_SECTION_COUNT] = {
+  % for i in find_all_sections(metadata):
+    ${path_name(i) | csyml},
+  % endfor
+};
+
+int camera_metadata_enum_snprint(uint32_t tag,
+                                 uint32_t value,
+                                 char *dst,
+                                 size_t size) {
+    const char *msg = "error: not an enum";
+    int ret = -1;
+
+    switch(tag) {
+    % for sec in find_all_sections(metadata):
+      % for idx,entry in enumerate(find_unique_entries(sec)):
+        case ${entry.name | csym}: {
+          % if entry.enum:
+            switch (value) {
+              % for val in entry.enum.values:
+                case ${entry.name | csym}_${val.name}:
+                    msg = "${val.name}";
+                    ret = 0;
+                    break;
+              % endfor
+                default:
+                    msg = "error: enum value out of range";
+            }
+          % endif
+            break;
+        }
+      % endfor
+
+    %endfor
+    }
+
+    strncpy(dst, msg, size - 1);
+    dst[size - 1] = '\0';
+
+    return ret;
+}
+
+<%
+  find_values = lambda x: isinstance(x, metadata_model.EnumValue)
+  enum_values = metadata.find_all(find_values)
+  enum_value_max_len = max([len(value.name) for value in enum_values]) + 1
+%>
+#define CAMERA_METADATA_ENUM_STRING_MAX_SIZE ${enum_value_max_len}
diff --git a/camera/docs/camera_metadata_tags.mako b/camera/docs/camera_metadata_tags.mako
index 184bc01..d7a5564 100644
--- a/camera/docs/camera_metadata_tags.mako
+++ b/camera/docs/camera_metadata_tags.mako
@@ -27,75 +27,6 @@
  * Generated automatically from camera_metadata_tags.mako
  */
 
-<%!
-  import metadata_model
-
-  def _is_sec_or_ins(x):
-    return isinstance(x, metadata_model.Section) or    \
-           isinstance(x, metadata_model.InnerNamespace)
-
-  ##
-  ## Metadata Helpers
-  ##
-
-  def find_all_sections(root):
-    return root.find_all(_is_sec_or_ins)
-
-  def find_parent_section(entry):
-    return entry.find_parent_first(_is_sec_or_ins)
-
-  # find uniquely named entries (w/o recursing through inner namespaces)
-  def find_unique_entries(node):
-    if not isinstance(node, metadata_model.Section) and    \
-       not isinstance(node, metadata_model.InnerNamespace):
-      raise TypeError("expected node to be a Section or InnerNamespace")
-
-    d = {}
-    # remove the 'kinds' from the path between sec and the closest entries
-    # then search the immediate children of the search path
-    search_path = isinstance(node, metadata_model.Section) and node.kinds \
-                  or [node]
-    for i in search_path:
-        for entry in i.entries:
-            d[entry.name] = entry
-
-    for k,v in d.iteritems():
-        yield v
-
-  def path_name(node):
-    isa = lambda x,y: isinstance(x, y)
-    fltr = lambda x: not isa(x, metadata_model.Metadata) and \
-                     not isa(x, metadata_model.Kind)
-
-    path = node.find_parents(fltr)
-    path = list(path)
-    path.reverse()
-    path.append(node)
-
-    return ".".join((i.name for i in path))
-
-  ##
-  ## Filters
-  ##
-
-  # abcDef.xyz -> ABC_DEF_XYZ
-  def csym(name):
-    newstr = name
-    newstr = "".join([i.isupper() and ("_" + i) or i for i in newstr]).upper()
-    newstr = newstr.replace(".", "_")
-    return newstr
-
-  # pad with spaces to make string len == size. add new line if too big
-  def ljust(size, indent=4):
-    def inner(what):
-        newstr = what.ljust(size)
-        if len(newstr) > size:
-            return what + "\n" + "".ljust(indent + size)
-        else:
-            return newstr
-    return inner
-%>
-
 /** TODO: Nearly every enum in this file needs a description */
 
 /**
@@ -119,7 +50,7 @@
  */
 typedef enum camera_metadata_section_start {
   % for i in find_all_sections(metadata):
-    ${path_name(i) + '.start' | csym,ljust(30)} = ${path_name(i) | csym,ljust(25)} << 16,
+    ${path_name(i) + '.start' | csym,ljust(30)} = ${path_name(i) | csym,pad(64)} << 16,
   % endfor
     VENDOR_SECTION_START           = VENDOR_SECTION            << 16
 } camera_metadata_section_start_t;
@@ -130,7 +61,7 @@
  * addition, the name and type of the tag needs to be added to
  * system/media/camera/src/camera_metadata_tag_info.c
  */
-enum camera_metadata_tag {
+typedef enum camera_metadata_tag {
     % for sec in find_all_sections(metadata):
       % for idx,entry in enumerate(find_unique_entries(sec)):
         % if idx == 0:
@@ -150,14 +81,14 @@
 
 % 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:
         % if val.id is None:
     ${entry.name | csym}_${val.name},
         % else:
-    ${'%s_%s'%(csym(entry.name), val.name) | ljust(30)} = ${val.id},
+    ${'%s_%s'%(csym(entry.name), val.name) | pad(65)} = ${val.id},
         % endif
       % endfor
 } camera_metadata_enum_${csym(entry.name).lower()}_t;
@@ -166,3 +97,8 @@
   % endfor
 
 %endfor
+
+int camera_metadata_enum_snprint(uint32_t tag,
+                                 uint32_t value,
+                                 char *dst,
+                                 size_t size);
diff --git a/camera/docs/docs.html b/camera/docs/docs.html
new file mode 100644
index 0000000..9f5ad50
--- /dev/null
+++ b/camera/docs/docs.html
@@ -0,0 +1,9930 @@
+<!DOCTYPE html>
+<html>
+<!-- Copyright (C) 2012 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<head>
+  <!-- automatically generated from html.mako. do NOT edit directly -->
+  <meta charset="utf-8" />
+  <title>Android Camera HAL2.0 Properties</title>
+  <style type="text/css">
+    .section { font-size: 1.5em; font-weight: bold; background-color: beige; padding: 0.5em 0em 0.5em 0.1em }
+    .kind { font-size: 1.2em; font-weight: bold; padding-left: 0.5em; background-color: gray }
+    .entry { background-color: burlywood }
+
+    /* table column sizes */
+    table { table-layout: fixed; width: 100%; word-wrap: break-word }
+    td,th { border: 1px solid;  }
+    .th_name { width: 20% }
+    .th_units { width: 10% }
+    .th_tags { width: 5% }
+    .th_notes { width: 30% }
+    .th_type { width: 20% }
+    td { font-size: 0.9em; }
+
+    /* hide the first thead, we need it there only to enforce column sizes */
+    .thead_dummy { visibility: hidden; }
+
+    /* Entry flair */
+    .entry_name { font-family: monospace; font-style: italic; }
+
+    /* Entry type flair */
+    .entry_type_name { color: darkgreen; font-weight: bold; }
+    .entry_type_name_enum:after { color: darkgreen; font-weight: bold; content:" (enum)" }
+    .entry_type_enum_name { font-family: monospace; font-weight: bolder; }
+    .entry_type_enum_notes:before { content:" - " }
+    .entry_type_enum_value:before { content:" = " }
+    .entry_type_enum_value { font-family: monospace; }
+    .entry ul { margin: 0 0 0 0; list-style-position: inside; padding-left: 0.5em; }
+    .entry ul li { padding: 0 0 0 0; margin: 0 0 0 0;}
+
+    /* Entry tags flair */
+    .entry_tags ul { list-style-type: none; }
+
+
+    /* TODO: generate abbr element for each tag link? */
+    /* TODO for each x.y.z try to link it to the entry */
+
+  </style>
+
+  <style>
+
+    {
+      /* broken...
+         supposedly there is a bug in chrome that it lays out tables before
+         it knows its being printed, so the page-break-* styles are ignored
+         */
+        tr { page-break-after: always; page-break-inside: avoid; }
+    }
+
+  </style>
+</head>
+
+
+
+
+<body>
+  <h1>Android Camera HAL2.0 Properties</h1>
+
+  <h2>Table of Contents</h2>
+  <ul class="toc">
+    <li><a href="#tag_index">Tags</a></li>
+
+
+    <li><p class="toc_section"><a href="#section_colorCorrection">colorCorrection</a></p>
+    <ul class="toc_section">
+        <li><a href="#controls_android.colorCorrection.mode">android.colorCorrection.mode</a> (controls)</li>
+        <li><a href="#controls_android.colorCorrection.transform">android.colorCorrection.transform</a> (controls)</li>
+        <li><a href="#dynamic_android.colorCorrection.mode">android.colorCorrection.mode</a> (dynamic)</li>
+    </ul>
+    </li> <!-- toc_section -->
+    <li><p class="toc_section"><a href="#section_control">control</a></p>
+    <ul class="toc_section">
+        <li><a href="#controls_android.control.aeAntibandingMode">android.control.aeAntibandingMode</a> (controls)</li>
+        <li><a href="#controls_android.control.aeExposureCompensation">android.control.aeExposureCompensation</a> (controls)</li>
+        <li><a href="#controls_android.control.aeLock">android.control.aeLock</a> (controls)</li>
+        <li><a href="#controls_android.control.aeMode">android.control.aeMode</a> (controls)</li>
+        <li><a href="#controls_android.control.aeRegions">android.control.aeRegions</a> (controls)</li>
+        <li><a href="#controls_android.control.aeTargetFpsRange">android.control.aeTargetFpsRange</a> (controls)</li>
+        <li><a href="#controls_android.control.afMode">android.control.afMode</a> (controls)</li>
+        <li><a href="#controls_android.control.afRegions">android.control.afRegions</a> (controls)</li>
+        <li><a href="#controls_android.control.awbLock">android.control.awbLock</a> (controls)</li>
+        <li><a href="#controls_android.control.awbMode">android.control.awbMode</a> (controls)</li>
+        <li><a href="#controls_android.control.awbRegions">android.control.awbRegions</a> (controls)</li>
+        <li><a href="#controls_android.control.captureIntent">android.control.captureIntent</a> (controls)</li>
+        <li><a href="#controls_android.control.effectMode">android.control.effectMode</a> (controls)</li>
+        <li><a href="#controls_android.control.mode">android.control.mode</a> (controls)</li>
+        <li><a href="#controls_android.control.sceneMode">android.control.sceneMode</a> (controls)</li>
+        <li><a href="#controls_android.control.videoStabilizationMode">android.control.videoStabilizationMode</a> (controls)</li>
+        <li><a href="#static_android.control.aeAvailableAntibandingModes">android.control.aeAvailableAntibandingModes</a> (static)</li>
+        <li><a href="#static_android.control.aeAvailableModes">android.control.aeAvailableModes</a> (static)</li>
+        <li><a href="#static_android.control.aeAvailableTargetFpsRanges">android.control.aeAvailableTargetFpsRanges</a> (static)</li>
+        <li><a href="#static_android.control.aeCompensationRange">android.control.aeCompensationRange</a> (static)</li>
+        <li><a href="#static_android.control.aeCompensationStep">android.control.aeCompensationStep</a> (static)</li>
+        <li><a href="#static_android.control.afAvailableModes">android.control.afAvailableModes</a> (static)</li>
+        <li><a href="#static_android.control.availableEffects">android.control.availableEffects</a> (static)</li>
+        <li><a href="#static_android.control.availableSceneModes">android.control.availableSceneModes</a> (static)</li>
+        <li><a href="#static_android.control.availableVideoStabilizationModes">android.control.availableVideoStabilizationModes</a> (static)</li>
+        <li><a href="#static_android.control.awbAvailableModes">android.control.awbAvailableModes</a> (static)</li>
+        <li><a href="#static_android.control.maxRegions">android.control.maxRegions</a> (static)</li>
+        <li><a href="#static_android.control.sceneModeOverrides">android.control.sceneModeOverrides</a> (static)</li>
+        <li><a href="#dynamic_android.control.aePrecaptureId">android.control.aePrecaptureId</a> (dynamic)</li>
+        <li><a href="#dynamic_android.control.aeRegions">android.control.aeRegions</a> (dynamic)</li>
+        <li><a href="#dynamic_android.control.aeState">android.control.aeState</a> (dynamic)</li>
+        <li><a href="#dynamic_android.control.afMode">android.control.afMode</a> (dynamic)</li>
+        <li><a href="#dynamic_android.control.afRegions">android.control.afRegions</a> (dynamic)</li>
+        <li><a href="#dynamic_android.control.afState">android.control.afState</a> (dynamic)</li>
+        <li><a href="#dynamic_android.control.afTriggerId">android.control.afTriggerId</a> (dynamic)</li>
+        <li><a href="#dynamic_android.control.awbMode">android.control.awbMode</a> (dynamic)</li>
+        <li><a href="#dynamic_android.control.awbRegions">android.control.awbRegions</a> (dynamic)</li>
+        <li><a href="#dynamic_android.control.awbState">android.control.awbState</a> (dynamic)</li>
+        <li><a href="#dynamic_android.control.mode">android.control.mode</a> (dynamic)</li>
+    </ul>
+    </li> <!-- toc_section -->
+    <li><p class="toc_section"><a href="#section_demosaic">demosaic</a></p>
+    <ul class="toc_section">
+        <li><a href="#controls_android.demosaic.mode">android.demosaic.mode</a> (controls)</li>
+    </ul>
+    </li> <!-- toc_section -->
+    <li><p class="toc_section"><a href="#section_edge">edge</a></p>
+    <ul class="toc_section">
+        <li><a href="#controls_android.edge.mode">android.edge.mode</a> (controls)</li>
+        <li><a href="#controls_android.edge.strength">android.edge.strength</a> (controls)</li>
+        <li><a href="#dynamic_android.edge.mode">android.edge.mode</a> (dynamic)</li>
+    </ul>
+    </li> <!-- toc_section -->
+    <li><p class="toc_section"><a href="#section_flash">flash</a></p>
+    <ul class="toc_section">
+        <li><a href="#controls_android.flash.firingPower">android.flash.firingPower</a> (controls)</li>
+        <li><a href="#controls_android.flash.firingTime">android.flash.firingTime</a> (controls)</li>
+        <li><a href="#controls_android.flash.mode">android.flash.mode</a> (controls)</li>
+        <li><a href="#static_android.flash.info.available">android.flash.info.available</a> (static)</li>
+        <li><a href="#static_android.flash.info.chargeDuration">android.flash.info.chargeDuration</a> (static)</li>
+        <li><a href="#static_android.flash.colorTemperature">android.flash.colorTemperature</a> (static)</li>
+        <li><a href="#static_android.flash.maxEnergy">android.flash.maxEnergy</a> (static)</li>
+        <li><a href="#dynamic_android.flash.firingPower">android.flash.firingPower</a> (dynamic)</li>
+        <li><a href="#dynamic_android.flash.firingTime">android.flash.firingTime</a> (dynamic)</li>
+        <li><a href="#dynamic_android.flash.mode">android.flash.mode</a> (dynamic)</li>
+        <li><a href="#dynamic_android.flash.state">android.flash.state</a> (dynamic)</li>
+    </ul>
+    </li> <!-- toc_section -->
+    <li><p class="toc_section"><a href="#section_geometric">geometric</a></p>
+    <ul class="toc_section">
+        <li><a href="#controls_android.geometric.mode">android.geometric.mode</a> (controls)</li>
+        <li><a href="#controls_android.geometric.strength">android.geometric.strength</a> (controls)</li>
+    </ul>
+    </li> <!-- toc_section -->
+    <li><p class="toc_section"><a href="#section_hotPixel">hotPixel</a></p>
+    <ul class="toc_section">
+        <li><a href="#controls_android.hotPixel.mode">android.hotPixel.mode</a> (controls)</li>
+        <li><a href="#static_android.hotPixel.info.map">android.hotPixel.info.map</a> (static)</li>
+        <li><a href="#dynamic_android.hotPixel.mode">android.hotPixel.mode</a> (dynamic)</li>
+    </ul>
+    </li> <!-- toc_section -->
+    <li><p class="toc_section"><a href="#section_jpeg">jpeg</a></p>
+    <ul class="toc_section">
+        <li><a href="#controls_android.jpeg.gpsCoordinates">android.jpeg.gpsCoordinates</a> (controls)</li>
+        <li><a href="#controls_android.jpeg.gpsProcessingMethod">android.jpeg.gpsProcessingMethod</a> (controls)</li>
+        <li><a href="#controls_android.jpeg.gpsTimestamp">android.jpeg.gpsTimestamp</a> (controls)</li>
+        <li><a href="#controls_android.jpeg.orientation">android.jpeg.orientation</a> (controls)</li>
+        <li><a href="#controls_android.jpeg.quality">android.jpeg.quality</a> (controls)</li>
+        <li><a href="#controls_android.jpeg.thumbnailQuality">android.jpeg.thumbnailQuality</a> (controls)</li>
+        <li><a href="#controls_android.jpeg.thumbnailSize">android.jpeg.thumbnailSize</a> (controls)</li>
+        <li><a href="#static_android.jpeg.availableThumbnailSizes">android.jpeg.availableThumbnailSizes</a> (static)</li>
+        <li><a href="#static_android.jpeg.maxSize">android.jpeg.maxSize</a> (static)</li>
+        <li><a href="#dynamic_android.jpeg.gpsCoordinates">android.jpeg.gpsCoordinates</a> (dynamic)</li>
+        <li><a href="#dynamic_android.jpeg.gpsProcessingMethod">android.jpeg.gpsProcessingMethod</a> (dynamic)</li>
+        <li><a href="#dynamic_android.jpeg.gpsTimestamp">android.jpeg.gpsTimestamp</a> (dynamic)</li>
+        <li><a href="#dynamic_android.jpeg.orientation">android.jpeg.orientation</a> (dynamic)</li>
+        <li><a href="#dynamic_android.jpeg.quality">android.jpeg.quality</a> (dynamic)</li>
+        <li><a href="#dynamic_android.jpeg.size">android.jpeg.size</a> (dynamic)</li>
+        <li><a href="#dynamic_android.jpeg.thumbnailQuality">android.jpeg.thumbnailQuality</a> (dynamic)</li>
+        <li><a href="#dynamic_android.jpeg.thumbnailSize">android.jpeg.thumbnailSize</a> (dynamic)</li>
+    </ul>
+    </li> <!-- toc_section -->
+    <li><p class="toc_section"><a href="#section_lens">lens</a></p>
+    <ul class="toc_section">
+        <li><a href="#controls_android.lens.aperture">android.lens.aperture</a> (controls)</li>
+        <li><a href="#controls_android.lens.filterDensity">android.lens.filterDensity</a> (controls)</li>
+        <li><a href="#controls_android.lens.focalLength">android.lens.focalLength</a> (controls)</li>
+        <li><a href="#controls_android.lens.focusDistance">android.lens.focusDistance</a> (controls)</li>
+        <li><a href="#controls_android.lens.opticalStabilizationMode">android.lens.opticalStabilizationMode</a> (controls)</li>
+        <li><a href="#static_android.lens.info.availableApertures">android.lens.info.availableApertures</a> (static)</li>
+        <li><a href="#static_android.lens.info.availableFilterDensities">android.lens.info.availableFilterDensities</a> (static)</li>
+        <li><a href="#static_android.lens.info.availableFocalLengths">android.lens.info.availableFocalLengths</a> (static)</li>
+        <li><a href="#static_android.lens.info.availableOpticalStabilization">android.lens.info.availableOpticalStabilization</a> (static)</li>
+        <li><a href="#static_android.lens.info.geometricCorrectionMap">android.lens.info.geometricCorrectionMap</a> (static)</li>
+        <li><a href="#static_android.lens.info.geometricCorrectionMapSize">android.lens.info.geometricCorrectionMapSize</a> (static)</li>
+        <li><a href="#static_android.lens.info.hyperfocalDistance">android.lens.info.hyperfocalDistance</a> (static)</li>
+        <li><a href="#static_android.lens.info.minimumFocusDistance">android.lens.info.minimumFocusDistance</a> (static)</li>
+        <li><a href="#static_android.lens.info.shadingMap">android.lens.info.shadingMap</a> (static)</li>
+        <li><a href="#static_android.lens.info.shadingMapSize">android.lens.info.shadingMapSize</a> (static)</li>
+        <li><a href="#static_android.lens.facing">android.lens.facing</a> (static)</li>
+        <li><a href="#static_android.lens.opticalAxisAngle">android.lens.opticalAxisAngle</a> (static)</li>
+        <li><a href="#static_android.lens.position">android.lens.position</a> (static)</li>
+        <li><a href="#dynamic_android.lens.aperture">android.lens.aperture</a> (dynamic)</li>
+        <li><a href="#dynamic_android.lens.filterDensity">android.lens.filterDensity</a> (dynamic)</li>
+        <li><a href="#dynamic_android.lens.focalLength">android.lens.focalLength</a> (dynamic)</li>
+        <li><a href="#dynamic_android.lens.focusDistance">android.lens.focusDistance</a> (dynamic)</li>
+        <li><a href="#dynamic_android.lens.focusRange">android.lens.focusRange</a> (dynamic)</li>
+        <li><a href="#dynamic_android.lens.opticalStabilizationMode">android.lens.opticalStabilizationMode</a> (dynamic)</li>
+        <li><a href="#dynamic_android.lens.state">android.lens.state</a> (dynamic)</li>
+    </ul>
+    </li> <!-- toc_section -->
+    <li><p class="toc_section"><a href="#section_noiseReduction">noiseReduction</a></p>
+    <ul class="toc_section">
+        <li><a href="#controls_android.noiseReduction.mode">android.noiseReduction.mode</a> (controls)</li>
+        <li><a href="#controls_android.noiseReduction.strength">android.noiseReduction.strength</a> (controls)</li>
+        <li><a href="#dynamic_android.noiseReduction.mode">android.noiseReduction.mode</a> (dynamic)</li>
+    </ul>
+    </li> <!-- toc_section -->
+    <li><p class="toc_section"><a href="#section_quirks">quirks</a></p>
+    <ul class="toc_section">
+        <li><a href="#static_android.quirks.meteringCropRegion">android.quirks.meteringCropRegion</a> (static)</li>
+        <li><a href="#static_android.quirks.triggerAfWithAuto">android.quirks.triggerAfWithAuto</a> (static)</li>
+        <li><a href="#static_android.quirks.useZslFormat">android.quirks.useZslFormat</a> (static)</li>
+    </ul>
+    </li> <!-- toc_section -->
+    <li><p class="toc_section"><a href="#section_request">request</a></p>
+    <ul class="toc_section">
+        <li><a href="#controls_android.request.frameCount">android.request.frameCount</a> (controls)</li>
+        <li><a href="#controls_android.request.id">android.request.id</a> (controls)</li>
+        <li><a href="#controls_android.request.inputStreams">android.request.inputStreams</a> (controls)</li>
+        <li><a href="#controls_android.request.metadataMode">android.request.metadataMode</a> (controls)</li>
+        <li><a href="#controls_android.request.outputStreams">android.request.outputStreams</a> (controls)</li>
+        <li><a href="#controls_android.request.type">android.request.type</a> (controls)</li>
+        <li><a href="#static_android.request.maxNumOutputStreams">android.request.maxNumOutputStreams</a> (static)</li>
+        <li><a href="#static_android.request.maxNumReprocessStreams">android.request.maxNumReprocessStreams</a> (static)</li>
+        <li><a href="#dynamic_android.request.frameCount">android.request.frameCount</a> (dynamic)</li>
+        <li><a href="#dynamic_android.request.id">android.request.id</a> (dynamic)</li>
+        <li><a href="#dynamic_android.request.metadataMode">android.request.metadataMode</a> (dynamic)</li>
+        <li><a href="#dynamic_android.request.outputStreams">android.request.outputStreams</a> (dynamic)</li>
+    </ul>
+    </li> <!-- toc_section -->
+    <li><p class="toc_section"><a href="#section_scaler">scaler</a></p>
+    <ul class="toc_section">
+        <li><a href="#controls_android.scaler.cropRegion">android.scaler.cropRegion</a> (controls)</li>
+        <li><a href="#static_android.scaler.availableFormats">android.scaler.availableFormats</a> (static)</li>
+        <li><a href="#static_android.scaler.availableJpegMinDurations">android.scaler.availableJpegMinDurations</a> (static)</li>
+        <li><a href="#static_android.scaler.availableJpegSizes">android.scaler.availableJpegSizes</a> (static)</li>
+        <li><a href="#static_android.scaler.availableMaxDigitalZoom">android.scaler.availableMaxDigitalZoom</a> (static)</li>
+        <li><a href="#static_android.scaler.availableProcessedMinDurations">android.scaler.availableProcessedMinDurations</a> (static)</li>
+        <li><a href="#static_android.scaler.availableProcessedSizes">android.scaler.availableProcessedSizes</a> (static)</li>
+        <li><a href="#static_android.scaler.availableRawMinDurations">android.scaler.availableRawMinDurations</a> (static)</li>
+        <li><a href="#static_android.scaler.availableRawSizes">android.scaler.availableRawSizes</a> (static)</li>
+        <li><a href="#static_android.scaler.maxDigitalZoom">android.scaler.maxDigitalZoom</a> (static)</li>
+        <li><a href="#dynamic_android.scaler.cropRegion">android.scaler.cropRegion</a> (dynamic)</li>
+    </ul>
+    </li> <!-- toc_section -->
+    <li><p class="toc_section"><a href="#section_sensor">sensor</a></p>
+    <ul class="toc_section">
+        <li><a href="#controls_android.sensor.exposureTime">android.sensor.exposureTime</a> (controls)</li>
+        <li><a href="#controls_android.sensor.frameDuration">android.sensor.frameDuration</a> (controls)</li>
+        <li><a href="#controls_android.sensor.sensitivity">android.sensor.sensitivity</a> (controls)</li>
+        <li><a href="#static_android.sensor.info.activeArraySize">android.sensor.info.activeArraySize</a> (static)</li>
+        <li><a href="#static_android.sensor.info.availableSensitivities">android.sensor.info.availableSensitivities</a> (static)</li>
+        <li><a href="#static_android.sensor.info.colorFilterArrangement">android.sensor.info.colorFilterArrangement</a> (static)</li>
+        <li><a href="#static_android.sensor.info.exposureTimeRange">android.sensor.info.exposureTimeRange</a> (static)</li>
+        <li><a href="#static_android.sensor.info.maxFrameDuration">android.sensor.info.maxFrameDuration</a> (static)</li>
+        <li><a href="#static_android.sensor.info.physicalSize">android.sensor.info.physicalSize</a> (static)</li>
+        <li><a href="#static_android.sensor.info.pixelArraySize">android.sensor.info.pixelArraySize</a> (static)</li>
+        <li><a href="#static_android.sensor.info.whiteLevel">android.sensor.info.whiteLevel</a> (static)</li>
+        <li><a href="#static_android.sensor.baseGainFactor">android.sensor.baseGainFactor</a> (static)</li>
+        <li><a href="#static_android.sensor.blackLevelPattern">android.sensor.blackLevelPattern</a> (static)</li>
+        <li><a href="#static_android.sensor.calibrationTransform1">android.sensor.calibrationTransform1</a> (static)</li>
+        <li><a href="#static_android.sensor.calibrationTransform2">android.sensor.calibrationTransform2</a> (static)</li>
+        <li><a href="#static_android.sensor.colorTransform1">android.sensor.colorTransform1</a> (static)</li>
+        <li><a href="#static_android.sensor.colorTransform2">android.sensor.colorTransform2</a> (static)</li>
+        <li><a href="#static_android.sensor.forwardMatrix1">android.sensor.forwardMatrix1</a> (static)</li>
+        <li><a href="#static_android.sensor.forwardMatrix2">android.sensor.forwardMatrix2</a> (static)</li>
+        <li><a href="#static_android.sensor.maxAnalogSensitivity">android.sensor.maxAnalogSensitivity</a> (static)</li>
+        <li><a href="#static_android.sensor.noiseModelCoefficients">android.sensor.noiseModelCoefficients</a> (static)</li>
+        <li><a href="#static_android.sensor.orientation">android.sensor.orientation</a> (static)</li>
+        <li><a href="#static_android.sensor.referenceIlluminant1">android.sensor.referenceIlluminant1</a> (static)</li>
+        <li><a href="#static_android.sensor.referenceIlluminant2">android.sensor.referenceIlluminant2</a> (static)</li>
+        <li><a href="#dynamic_android.sensor.exposureTime">android.sensor.exposureTime</a> (dynamic)</li>
+        <li><a href="#dynamic_android.sensor.frameDuration">android.sensor.frameDuration</a> (dynamic)</li>
+        <li><a href="#dynamic_android.sensor.sensitivity">android.sensor.sensitivity</a> (dynamic)</li>
+        <li><a href="#dynamic_android.sensor.timestamp">android.sensor.timestamp</a> (dynamic)</li>
+    </ul>
+    </li> <!-- toc_section -->
+    <li><p class="toc_section"><a href="#section_shading">shading</a></p>
+    <ul class="toc_section">
+        <li><a href="#controls_android.shading.mode">android.shading.mode</a> (controls)</li>
+        <li><a href="#controls_android.shading.strength">android.shading.strength</a> (controls)</li>
+        <li><a href="#dynamic_android.shading.mode">android.shading.mode</a> (dynamic)</li>
+    </ul>
+    </li> <!-- toc_section -->
+    <li><p class="toc_section"><a href="#section_statistics">statistics</a></p>
+    <ul class="toc_section">
+        <li><a href="#controls_android.statistics.faceDetectMode">android.statistics.faceDetectMode</a> (controls)</li>
+        <li><a href="#controls_android.statistics.histogramMode">android.statistics.histogramMode</a> (controls)</li>
+        <li><a href="#controls_android.statistics.sharpnessMapMode">android.statistics.sharpnessMapMode</a> (controls)</li>
+        <li><a href="#static_android.statistics.info.availableFaceDetectModes">android.statistics.info.availableFaceDetectModes</a> (static)</li>
+        <li><a href="#static_android.statistics.info.histogramBucketCount">android.statistics.info.histogramBucketCount</a> (static)</li>
+        <li><a href="#static_android.statistics.info.maxFaceCount">android.statistics.info.maxFaceCount</a> (static)</li>
+        <li><a href="#static_android.statistics.info.maxHistogramCount">android.statistics.info.maxHistogramCount</a> (static)</li>
+        <li><a href="#static_android.statistics.info.maxSharpnessMapValue">android.statistics.info.maxSharpnessMapValue</a> (static)</li>
+        <li><a href="#static_android.statistics.info.sharpnessMapSize">android.statistics.info.sharpnessMapSize</a> (static)</li>
+        <li><a href="#dynamic_android.statistics.faceDetectMode">android.statistics.faceDetectMode</a> (dynamic)</li>
+        <li><a href="#dynamic_android.statistics.faceIds">android.statistics.faceIds</a> (dynamic)</li>
+        <li><a href="#dynamic_android.statistics.faceLandmarks">android.statistics.faceLandmarks</a> (dynamic)</li>
+        <li><a href="#dynamic_android.statistics.faceRectangles">android.statistics.faceRectangles</a> (dynamic)</li>
+        <li><a href="#dynamic_android.statistics.faceScores">android.statistics.faceScores</a> (dynamic)</li>
+        <li><a href="#dynamic_android.statistics.histogram">android.statistics.histogram</a> (dynamic)</li>
+        <li><a href="#dynamic_android.statistics.histogramMode">android.statistics.histogramMode</a> (dynamic)</li>
+        <li><a href="#dynamic_android.statistics.sharpnessMap">android.statistics.sharpnessMap</a> (dynamic)</li>
+        <li><a href="#dynamic_android.statistics.sharpnessMapMode">android.statistics.sharpnessMapMode</a> (dynamic)</li>
+    </ul>
+    </li> <!-- toc_section -->
+    <li><p class="toc_section"><a href="#section_tonemap">tonemap</a></p>
+    <ul class="toc_section">
+        <li><a href="#controls_android.tonemap.curveBlue">android.tonemap.curveBlue</a> (controls)</li>
+        <li><a href="#controls_android.tonemap.curveGreen">android.tonemap.curveGreen</a> (controls)</li>
+        <li><a href="#controls_android.tonemap.curveRed">android.tonemap.curveRed</a> (controls)</li>
+        <li><a href="#controls_android.tonemap.mode">android.tonemap.mode</a> (controls)</li>
+        <li><a href="#static_android.tonemap.maxCurvePoints">android.tonemap.maxCurvePoints</a> (static)</li>
+        <li><a href="#dynamic_android.tonemap.curveBlue">android.tonemap.curveBlue</a> (dynamic)</li>
+        <li><a href="#dynamic_android.tonemap.curveGreen">android.tonemap.curveGreen</a> (dynamic)</li>
+        <li><a href="#dynamic_android.tonemap.curveRed">android.tonemap.curveRed</a> (dynamic)</li>
+        <li><a href="#dynamic_android.tonemap.mode">android.tonemap.mode</a> (dynamic)</li>
+    </ul>
+    </li> <!-- toc_section -->
+  </ul>
+
+  <h1>Properties</h1>
+  <table class="properties">
+
+    <thead class="thead_dummy">
+      <tr>
+        <th class="th_name">Property Name</th>
+        <th class="th_type">Type</th>
+        <th class="th_description">Description</th>
+        <th class="th_units">Units</th>
+        <th class="th_range">Range</th>
+        <th class="th_notes">Notes</th>
+        <th class="th_tags">Tags</th>
+      </tr>
+    </thead> <!-- so that the first occurrence of thead is not
+                         above the first occurrence of tr -->
+<!-- <namespace name="android"> -->
+  <tr><td colspan="7" id="section_colorCorrection" class="section">colorCorrection</td></tr>
+
+
+      <tr><td colspan="7" class="kind">controls</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="controls_android.colorCorrection.mode">
+            <td class="entry_name">android.<wbr>color<wbr>Correction.<wbr>mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">TRANSFORM_MATRIX</span>
+                    <span class="entry_type_enum_notes">Use the android.<wbr>color<wbr>Correction.<wbr>transform matrix
+              to do color conversion</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">FAST</span>
+                    <span class="entry_type_enum_notes">Must not slow down frame rate relative to raw
+              bayer output</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">HIGH_QUALITY</span>
+                    <span class="entry_type_enum_notes">Frame rate may be reduced by high
+              quality</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.colorCorrection.transform">
+            <td class="entry_name">android.<wbr>color<wbr>Correction.<wbr>transform</td>
+            <td class="entry_type">
+                <span class="entry_type_name">float</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  3 x 3
+                </span>
+
+                <div class="entry_type_notes">3x3 float matrix in row-major order</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              A transform matrix to chromatically adapt
+          pixels in the CIE XYZ (1931) color space from the scene
+          illuminant to the sRGB-standard
+          D65-illuminant
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              Output values are expected to be in the range
+          (0,<wbr>1)
+            </td>
+
+            <td class="entry_notes">
+              Values outside (0,<wbr>1) should be clamped.<wbr> Need to
+          provide utilities to go from CCT (+hue?),<wbr> or (x,<wbr>y) white
+          point,<wbr> (or AWB mode) to matrix; use linear Bradford
+          algorithm.<wbr>
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+      <tr><td colspan="7" class="kind">dynamic</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="dynamic_android.colorCorrection.mode">
+            <td class="entry_name">android.<wbr>color<wbr>Correction.<wbr>mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">TRANSFORM_MATRIX</span>
+                    <span class="entry_type_enum_notes">Use the android.<wbr>color<wbr>Correction.<wbr>transform matrix
+              to do color conversion</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">FAST</span>
+                    <span class="entry_type_enum_notes">Must not slow down frame rate relative to raw
+              bayer output</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">HIGH_QUALITY</span>
+                    <span class="entry_type_enum_notes">Frame rate may be reduced by high
+              quality</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+
+  <!-- end of section -->
+  <tr><td colspan="7" id="section_control" class="section">control</td></tr>
+
+
+      <tr><td colspan="7" class="kind">controls</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="controls_android.control.aeAntibandingMode">
+            <td class="entry_name">android.<wbr>control.<wbr>ae<wbr>Antibanding<wbr>Mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">OFF</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">50HZ</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">60HZ</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">AUTO</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Enum for controlling
+          antibanding
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              
+          android.<wbr>control.<wbr>ae<wbr>Available<wbr>Antibanding<wbr>Modes
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.control.aeExposureCompensation">
+            <td class="entry_name">android.<wbr>control.<wbr>ae<wbr>Exposure<wbr>Compensation</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Adjustment to AE target image
+          brightness
+            </td>
+
+            <td class="entry_units">
+              count of positive/<wbr>negative EV steps
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              For example,<wbr> if EV step is 0.<wbr>333,<wbr> '6' will mean an
+          exposure compensation of +2 EV; -3 will mean an exposure
+          compensation of -1
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.control.aeLock">
+            <td class="entry_name">android.<wbr>control.<wbr>ae<wbr>Lock</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">OFF</span>
+                    <span class="entry_type_enum_notes">Autoexposure lock is disabled; the AE algorithm
+            is free to update its parameters.<wbr></span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">ON</span>
+                    <span class="entry_type_enum_notes">Autoexposure lock is enabled; the AE algorithm
+            must not update the exposure and sensitivity parameters
+            while the lock is active</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Whether AE is currently locked to its latest
+          calculated values
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              Note that even when AE is locked,<wbr> the flash may be
+          fired if the AE mode is ON_<wbr>AUTO_<wbr>FLASH /<wbr> ON_<wbr>ALWAYS_<wbr>FLASH /<wbr>
+          ON_<wbr>AUTO_<wbr>FLASH_<wbr>REDEYE.<wbr>
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.control.aeMode">
+            <td class="entry_name">android.<wbr>control.<wbr>ae<wbr>Mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">OFF</span>
+                    <span class="entry_type_enum_notes">Autoexposure is disabled; sensor.<wbr>exposureTime
+              and sensor.<wbr>sensitivity are used</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">ON</span>
+                    <span class="entry_type_enum_notes">Autoexposure is active,<wbr> no flash
+              control</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">ON_AUTO_FLASH</span>
+                    <span class="entry_type_enum_notes">if flash exists Autoexposure is active,<wbr> auto
+            flash control; flash may be fired when precapture
+            trigger is activated,<wbr> and for captures for which
+            captureIntent = STILL_<wbr>CAPTURE</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">ON_ALWAYS_FLASH</span>
+                    <span class="entry_type_enum_notes">if flash exists Autoexposure is active,<wbr> auto
+            flash control for precapture trigger and always flash
+            when captureIntent = STILL_<wbr>CAPTURE</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">ON_AUTO_FLASH_REDEYE</span>
+                    <span class="entry_type_enum_notes">optional Automatic red eye reduction with flash.<wbr>
+            If deemed necessary,<wbr> red eye reduction sequence should
+            fire when precapture trigger is activated,<wbr> and final
+            flash should fire when captureIntent =
+            STILL_<wbr>CAPTURE</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Whether AE is currently updating the sensor
+          exposure and sensitivity fields
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              android.<wbr>control.<wbr>ae<wbr>Available<wbr>Modes
+            </td>
+
+            <td class="entry_notes">
+              Only effective if android.<wbr>control.<wbr>mode =
+          AUTO
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.control.aeRegions">
+            <td class="entry_name">android.<wbr>control.<wbr>ae<wbr>Regions</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  5 x area_count
+                </span>
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              List of areas to use for
+          metering
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              Each area is a rectangle plus weight: xmin,<wbr> ymin,<wbr>
+          xmax,<wbr> ymax,<wbr> weight.<wbr> The coordinate system is based on the
+          active pixel array,<wbr> with (0,<wbr>0) being the top-left of the
+          active pixel array,<wbr> and
+          (android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>width,<wbr>
+          android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>height) being the
+          bottom-right point of the active pixel array.<wbr> The weight
+          should be nonnegative.<wbr> If all regions have 0 weight,<wbr> then
+          no specific metering area needs to be used by the HAL.<wbr> If
+          the metering region is outside the current
+          android.<wbr>scaler.<wbr>crop<wbr>Region,<wbr> the HAL should ignore the
+          sections outside the region and output the used sections
+          in the frame metadata
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.control.aeTargetFpsRange">
+            <td class="entry_name">android.<wbr>control.<wbr>ae<wbr>Target<wbr>Fps<wbr>Range</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  2
+                </span>
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Range over which fps can be adjusted to
+          maintain exposure
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              android.<wbr>control.<wbr>ae<wbr>Available<wbr>Target<wbr>Fps<wbr>Ranges
+            </td>
+
+            <td class="entry_notes">
+              Only constrains AE algorithm,<wbr> not manual control
+          of android.<wbr>sensor.<wbr>exposure<wbr>Time
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.control.afMode">
+            <td class="entry_name">android.<wbr>control.<wbr>af<wbr>Mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">OFF</span>
+                    <span class="entry_type_enum_notes">The 3A routines do not control the lens;
+            android.<wbr>lens.<wbr>focus<wbr>Position is controlled by the
+            application</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">AUTO</span>
+                    <span class="entry_type_enum_notes">if lens is not fixed focus.<wbr> Use
+            android.<wbr>lens.<wbr>minimum<wbr>Focus<wbr>Distance to determine if lens
+            is fixed focus In this mode,<wbr> the lens does not move
+            unless the autofocus trigger action is called.<wbr> When
+            that trigger is activated,<wbr> AF must transition to
+            ACTIVE_<wbr>SCAN,<wbr> then to the outcome of the scan (FOCUSED
+            or NOT_<wbr>FOCUSED).<wbr> Triggering cancel AF resets the lens
+            position to default,<wbr> and sets the AF state to
+            INACTIVE.<wbr></span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">MACRO</span>
+                    <span class="entry_type_enum_notes">In this mode,<wbr> the lens does not move unless the
+            autofocus trigger action is called.<wbr> When that trigger
+            is activated,<wbr> AF must transition to ACTIVE_<wbr>SCAN,<wbr> then
+            to the outcome of the scan (FOCUSED or NOT_<wbr>FOCUSED).<wbr>
+            Triggering cancel AF resets the lens position to
+            default,<wbr> and sets the AF state to
+            INACTIVE.<wbr></span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">CONTINUOUS_VIDEO</span>
+                    <span class="entry_type_enum_notes">In this mode,<wbr> the AF algorithm modifies the lens
+            position continually to attempt to provide a
+            constantly-in-focus image stream.<wbr> The focusing behavior
+            should be suitable for good quality video recording;
+            typically this means slower focus movement and no
+            overshoots.<wbr> When the AF trigger is not involved,<wbr> the AF
+            algorithm should start in INACTIVE state,<wbr> and then
+            transition into PASSIVE_<wbr>SCAN and PASSIVE_<wbr>FOCUSED states
+            as appropriate.<wbr> When the AF trigger is activated,<wbr> the
+            algorithm should immediately transition into AF_<wbr>FOCUSED
+            or AF_<wbr>NOT_<wbr>FOCUSED as appropriate,<wbr> and lock the lens
+            position until a cancel AF trigger is received.<wbr> Once
+            cancel is received,<wbr> the algorithm should transition
+            back to INACTIVE and resume passive scan.<wbr> Note that
+            this behavior is not identical to CONTINUOUS_<wbr>PICTURE,<wbr>
+            since an ongoing PASSIVE_<wbr>SCAN must immediately be
+            canceled.<wbr></span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">CONTINUOUS_PICTURE</span>
+                    <span class="entry_type_enum_notes">In this mode,<wbr> the AF algorithm modifies the lens
+            position continually to attempt to provide a
+            constantly-in-focus image stream.<wbr> The focusing behavior
+            should be suitable for still image capture; typically
+            this means focusing as fast as possible.<wbr> When the AF
+            trigger is not involved,<wbr> the AF algorithm should start
+            in INACTIVE state,<wbr> and then transition into
+            PASSIVE_<wbr>SCAN and PASSIVE_<wbr>FOCUSED states as appropriate
+            as it attempts to maintain focus.<wbr> When the AF trigger
+            is activated,<wbr> the algorithm should finish its
+            PASSIVE_<wbr>SCAN if active,<wbr> and then transition into
+            AF_<wbr>FOCUSED or AF_<wbr>NOT_<wbr>FOCUSED as appropriate,<wbr> and lock
+            the lens position until a cancel AF trigger is
+            received.<wbr> When the AF cancel trigger is activated,<wbr> the
+            algorithm should transition back to INACTIVE and then
+            act as if it has just been started.<wbr></span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">EDOF</span>
+                    <span class="entry_type_enum_notes">Extended depth of field (digital focus).<wbr> AF
+            trigger is ignored,<wbr> AF state should always be
+            INACTIVE.<wbr></span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Whether AF is currently enabled,<wbr> and what
+          mode it is set to
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.control.afRegions">
+            <td class="entry_name">android.<wbr>control.<wbr>af<wbr>Regions</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  5 x area_count
+                </span>
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              List of areas to use for focus
+          estimation
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              Each area is a rectangle plus weight: xmin,<wbr> ymin,<wbr>
+          xmax,<wbr> ymax,<wbr> weight.<wbr> The coordinate system is based on the
+          active pixel array,<wbr> with (0,<wbr>0) being the top-left of the
+          active pixel array,<wbr> and
+          (android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>width,<wbr>
+          android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>height) being the
+          bottom-right point of the active pixel array.<wbr> The weight
+          should be nonnegative.<wbr> If all regions have 0 weight,<wbr> then
+          no specific focus area needs to be used by the HAL.<wbr> If
+          the focusing region is outside the current
+          android.<wbr>scaler.<wbr>crop<wbr>Region,<wbr> the HAL should ignore the
+          sections outside the region and output the used sections
+          in the frame metadata
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.control.awbLock">
+            <td class="entry_name">android.<wbr>control.<wbr>awb<wbr>Lock</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">OFF</span>
+                    <span class="entry_type_enum_notes">Auto-whitebalance lock is disabled; the AWB
+            algorithm is free to update its parameters if in AUTO
+            mode.<wbr></span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">ON</span>
+                    <span class="entry_type_enum_notes">Auto-whitebalance lock is enabled; the AWB
+            algorithm must not update the exposure and sensitivity
+            parameters while the lock is active</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Whether AWB is currently locked to its
+          latest calculated values
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              Note that AWB lock is only meaningful for AUTO
+          mode; in other modes,<wbr> AWB is already fixed to a specific
+          setting
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.control.awbMode">
+            <td class="entry_name">android.<wbr>control.<wbr>awb<wbr>Mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">OFF</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">AUTO</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">INCANDESCENT</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">FLUORESCENT</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">WARM_FLUORESCENT</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">DAYLIGHT</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">CLOUDY_DAYLIGHT</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">TWILIGHT</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">SHADE</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Whether AWB is currently setting the color
+          transform fields,<wbr> and what its illumination target
+          is
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              [BC - AWB lock,<wbr>AWB modes]
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+                  <li><a href="#tag_AWB">AWB</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.control.awbRegions">
+            <td class="entry_name">android.<wbr>control.<wbr>awb<wbr>Regions</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  5 x area_count
+                </span>
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              List of areas to use for illuminant
+          estimation
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              Only used in AUTO mode.<wbr> Each area is a rectangle
+          plus weight: xmin,<wbr> ymin,<wbr> xmax,<wbr> ymax,<wbr> weight.<wbr> The
+          coordinate system is based on the active pixel array,<wbr>
+          with (0,<wbr>0) being the top-left of the active pixel array,<wbr>
+          and (android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>width,<wbr>
+          android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>height) being the
+          bottom-right point of the active pixel array.<wbr> The weight
+          should be nonnegative.<wbr> If all regions have 0 weight,<wbr> then
+          no specific metering area needs to be used by the HAL.<wbr> If
+          the metering region is outside the current
+          android.<wbr>scaler.<wbr>crop<wbr>Region,<wbr> the HAL should ignore the
+          sections outside the region and output the used sections
+          in the frame metadata
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.control.captureIntent">
+            <td class="entry_name">android.<wbr>control.<wbr>capture<wbr>Intent</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">CUSTOM</span>
+                    <span class="entry_type_enum_notes">This request doesn't fall into the other
+            categories.<wbr> Default to preview-like
+            behavior.<wbr></span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">PREVIEW</span>
+                    <span class="entry_type_enum_notes">This request is for a preview-like usecase.<wbr> The
+            precapture trigger may be used to start off a metering
+            w/<wbr>flash sequence</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">STILL_CAPTURE</span>
+                    <span class="entry_type_enum_notes">This request is for a still capture-type
+            usecase.<wbr></span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">VIDEO_RECORD</span>
+                    <span class="entry_type_enum_notes">This request is for a video recording
+            usecase.<wbr></span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">VIDEO_SNAPSHOT</span>
+                    <span class="entry_type_enum_notes">This request is for a video snapshot (still
+            image while recording video) usecase</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">ZERO_SHUTTER_LAG</span>
+                    <span class="entry_type_enum_notes">This request is for a ZSL usecase; the
+            application will stream full-resolution images and
+            reprocess one or several later for a final
+            capture</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Information to 3A routines about the purpose
+          of this capture,<wbr> to help decide optimal 3A
+          strategy
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              all must be supported
+            </td>
+
+            <td class="entry_notes">
+              Only used if android.<wbr>control.<wbr>mode != OFF.<wbr>
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.control.effectMode">
+            <td class="entry_name">android.<wbr>control.<wbr>effect<wbr>Mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">OFF</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">MONO</span>
+                    <span class="entry_type_enum_optional">optional</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">NEGATIVE</span>
+                    <span class="entry_type_enum_optional">optional</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">SOLARIZE</span>
+                    <span class="entry_type_enum_optional">optional</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">SEPIA</span>
+                    <span class="entry_type_enum_optional">optional</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">POSTERIZE</span>
+                    <span class="entry_type_enum_optional">optional</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">WHITEBOARD</span>
+                    <span class="entry_type_enum_optional">optional</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">BLACKBOARD</span>
+                    <span class="entry_type_enum_optional">optional</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">AQUA</span>
+                    <span class="entry_type_enum_optional">optional</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Whether any special color effect is in use.<wbr>
+          Only used if android.<wbr>control.<wbr>mode != OFF
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              android.<wbr>control.<wbr>available<wbr>Effects
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.control.mode">
+            <td class="entry_name">android.<wbr>control.<wbr>mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">OFF</span>
+                    <span class="entry_type_enum_notes">Full application control of pipeline.<wbr> All 3A
+            routines are disabled,<wbr> no other settings in
+            android.<wbr>control.<wbr>* have any effect</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">AUTO</span>
+                    <span class="entry_type_enum_notes">Use settings for each individual 3A routine.<wbr>
+            Manual control of capture parameters is disabled.<wbr> All
+            controls in android.<wbr>control.<wbr>* besides sceneMode take
+            effect</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">USE_SCENE_MODE</span>
+                    <span class="entry_type_enum_notes">Use specific scene mode.<wbr> Enabling this disables
+            control.<wbr>aeMode,<wbr> control.<wbr>awbMode and control.<wbr>afMode
+            controls; the HAL must ignore those settings while
+            USE_<wbr>SCENE_<wbr>MODE is active (except for FACE_<wbr>PRIORITY
+            scene mode).<wbr> Other control entries are still active.<wbr>
+            This setting can only be used if availableSceneModes !=
+            UNSUPPORTED</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Overall mode of 3A control
+          routines
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              all must be supported
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.control.sceneMode">
+            <td class="entry_name">android.<wbr>control.<wbr>scene<wbr>Mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">UNSUPPORTED</span>
+                    <span class="entry_type_enum_value">0</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">FACE_PRIORITY</span>
+                    <span class="entry_type_enum_notes">if face detection support exists Use face
+            detection data to drive 3A routines.<wbr> If face detection
+            statistics are disabled,<wbr> should still operate correctly
+            (but not return face detection statistics to the
+            framework).<wbr> Unlike the other scene modes,<wbr> aeMode,<wbr>
+            awbMode,<wbr> and afMode remain active when FACE_<wbr>PRIORITY is
+            set.<wbr> This is due to compatibility concerns with the old
+            camera API</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">ACTION</span>
+                    <span class="entry_type_enum_optional">optional</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">PORTRAIT</span>
+                    <span class="entry_type_enum_optional">optional</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">LANDSCAPE</span>
+                    <span class="entry_type_enum_optional">optional</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">NIGHT</span>
+                    <span class="entry_type_enum_optional">optional</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">NIGHT_PORTRAIT</span>
+                    <span class="entry_type_enum_optional">optional</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">THEATRE</span>
+                    <span class="entry_type_enum_optional">optional</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">BEACH</span>
+                    <span class="entry_type_enum_optional">optional</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">SNOW</span>
+                    <span class="entry_type_enum_optional">optional</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">SUNSET</span>
+                    <span class="entry_type_enum_optional">optional</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">STEADYPHOTO</span>
+                    <span class="entry_type_enum_optional">optional</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">FIREWORKS</span>
+                    <span class="entry_type_enum_optional">optional</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">SPORTS</span>
+                    <span class="entry_type_enum_optional">optional</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">PARTY</span>
+                    <span class="entry_type_enum_optional">optional</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">CANDLELIGHT</span>
+                    <span class="entry_type_enum_optional">optional</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">BARCODE</span>
+                    <span class="entry_type_enum_optional">optional</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Which scene mode is active when
+          android.<wbr>control.<wbr>mode = SCENE_<wbr>MODE
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              android.<wbr>control.<wbr>available<wbr>Scene<wbr>Modes
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.control.videoStabilizationMode">
+            <td class="entry_name">android.<wbr>control.<wbr>video<wbr>Stabilization<wbr>Mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">OFF</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">ON</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Whether video stabilization is
+          active
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              If enabled,<wbr> video stabilization can modify the
+          android.<wbr>scaler.<wbr>crop<wbr>Region to keep the video stream
+          stabilized
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+      <tr><td colspan="7" class="kind">static</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="static_android.control.aeAvailableAntibandingModes">
+            <td class="entry_name">android.<wbr>control.<wbr>ae<wbr>Available<wbr>Antibanding<wbr>Modes</td>
+            <td class="entry_type">
+                <span class="entry_type_name">byte</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  n
+                </span>
+
+                <div class="entry_type_notes">list of enums</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Which set of antibanding modes are
+          supported
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.control.aeAvailableModes">
+            <td class="entry_name">android.<wbr>control.<wbr>ae<wbr>Available<wbr>Modes</td>
+            <td class="entry_type">
+                <span class="entry_type_name">byte</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  n
+                </span>
+
+                <div class="entry_type_notes">list of enums</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Which subset of AE modes is
+          supported
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              OFF,<wbr> ON must be supported.<wbr>
+          ON_<wbr>AUTO_<wbr>FLASH/<wbr>ON_<wbr>ALWAYS_<wbr>FLASH must be supported if flash
+          unit is available
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.control.aeAvailableTargetFpsRanges">
+            <td class="entry_name">android.<wbr>control.<wbr>ae<wbr>Available<wbr>Target<wbr>Fps<wbr>Ranges</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  2 x n
+                </span>
+
+                <div class="entry_type_notes">list of pairs of frame rates</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              List of frame rate ranges supported by the
+          AE algorithm/<wbr>hardware
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.control.aeCompensationRange">
+            <td class="entry_name">android.<wbr>control.<wbr>ae<wbr>Compensation<wbr>Range</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  2
+                </span>
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Maximum and minimum exposure compensation
+          setting,<wbr> in counts of
+          android.<wbr>control.<wbr>ae<wbr>Compensation<wbr>Step<wbr>Size
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              At least (-2,<wbr>2)/<wbr>(exp compensation step
+          size)
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.control.aeCompensationStep">
+            <td class="entry_name">android.<wbr>control.<wbr>ae<wbr>Compensation<wbr>Step</td>
+            <td class="entry_type">
+                <span class="entry_type_name">rational</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Smallest step by which exposure compensation
+          can be changed
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              <= 1/<wbr>2
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.control.afAvailableModes">
+            <td class="entry_name">android.<wbr>control.<wbr>af<wbr>Available<wbr>Modes</td>
+            <td class="entry_type">
+                <span class="entry_type_name">byte</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  n
+                </span>
+
+                <div class="entry_type_notes">List of enums</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              List of AF modes that can be
+          selected
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              OFF must be included.<wbr> AUTO must be supported if
+          lens allows for changing focus
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.control.availableEffects">
+            <td class="entry_name">android.<wbr>control.<wbr>available<wbr>Effects</td>
+            <td class="entry_type">
+                <span class="entry_type_name">byte</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  n
+                </span>
+
+                <div class="entry_type_notes">list of enums</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              what subset of the full color effect enum
+          list is supported
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              OFF must be listed
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.control.availableSceneModes">
+            <td class="entry_name">android.<wbr>control.<wbr>available<wbr>Scene<wbr>Modes</td>
+            <td class="entry_type">
+                <span class="entry_type_name">byte</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  n
+                </span>
+
+                <div class="entry_type_notes">list of enums from android.<wbr>control.<wbr>scene<wbr>Mode,<wbr> plus UNSUPPORTED to indicate no scene modes are supported</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              what subset of the scene mode enum list is
+          supported.<wbr>
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              SCENE_<wbr>MODE_<wbr>FACE_<wbr>PRIORITY must be supported if face
+          detection is supported
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.control.availableVideoStabilizationModes">
+            <td class="entry_name">android.<wbr>control.<wbr>available<wbr>Video<wbr>Stabilization<wbr>Modes</td>
+            <td class="entry_type">
+                <span class="entry_type_name">byte</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  n
+                </span>
+
+                <div class="entry_type_notes">List of enums.<wbr></div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              List of video stabilization modes that can
+          be supported
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              OFF must be included
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.control.awbAvailableModes">
+            <td class="entry_name">android.<wbr>control.<wbr>awb<wbr>Available<wbr>Modes</td>
+            <td class="entry_type">
+                <span class="entry_type_name">byte</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+            </td>
+
+            <td class="entry_units">
+              List of enums (android.<wbr>control.<wbr>awb<wbr>Mode)
+            </td>
+
+            <td class="entry_range">
+              OFF,<wbr> AUTO must be included
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.control.maxRegions">
+            <td class="entry_name">android.<wbr>control.<wbr>max<wbr>Regions</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              For AE,<wbr> AWB,<wbr> and AF,<wbr> how many individual
+          regions can be listed for metering?
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              >= 1
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.control.sceneModeOverrides">
+            <td class="entry_name">android.<wbr>control.<wbr>scene<wbr>Mode<wbr>Overrides</td>
+            <td class="entry_type">
+                <span class="entry_type_name">byte</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  3 x lengthavailablescenemodes
+                </span>
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              List of AE,<wbr> AWB,<wbr> and AF modes to use for
+          each available scene mode
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              For each listed scene mode,<wbr> lists the aeMode,<wbr>
+          awbMode,<wbr> and afMode that the HAL wants to use for that
+          scene mode.<wbr> For each entry,<wbr> the order is {aeMode,<wbr>
+          awbMode,<wbr> afMode} in order of increasing index
+            </td>
+
+            <td class="entry_notes">
+              When a scene mode is enabled,<wbr> the HAL is expected
+          to override aeMode,<wbr> awbMode,<wbr> and afMode with its
+          preferred settings for that scene mode.<wbr> To simplify
+          communication with old camera API applications,<wbr> the
+          service wants this override list in the static metadata.<wbr>
+          The order of this list matches that of
+          availableSceneModes,<wbr> with 3 entires for each scene mode.<wbr>
+          The overrides listed for SCENE_<wbr>MODE_<wbr>FACE_<wbr>PRIORITY are
+          ignored,<wbr> since for that mode,<wbr> the application-set aeMode,<wbr>
+          awbMode,<wbr> and afMode are used instead,<wbr> like they are when
+          android.<wbr>control.<wbr>mode is AUTO.<wbr> It is recommended that for
+          FACE_<wbr>PRIORITY,<wbr> the overrides should be set to 0.<wbr> As an
+          example,<wbr> if availableSceneModes is { FACE_<wbr>PRIORITY,<wbr>
+          ACTION,<wbr> NIGHT },<wbr> then the service expects this field to
+          have 9 entries; for example { 0 ,<wbr> 0,<wbr> 0,<wbr> ON_<wbr>AUTO_<wbr>FLASH,<wbr>
+          AUTO,<wbr> CONTINUOUS_<wbr>PICTURE,<wbr> ON_<wbr>AUTO_<wbr>FLASH,<wbr> INCANDESCENT,<wbr>
+          AUTO }
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+      <tr><td colspan="7" class="kind">dynamic</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="dynamic_android.control.aePrecaptureId">
+            <td class="entry_name">android.<wbr>control.<wbr>ae<wbr>Precapture<wbr>Id</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              The ID sent with the latest
+          CAMERA2_<wbr>TRIGGER_<wbr>PRECAPTURE_<wbr>METERING call
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              Must be 0 if no
+          CAMERA2_<wbr>TRIGGER_<wbr>PRECAPTURE_<wbr>METERING trigger received yet
+          by HAL.<wbr> Always updated even if AE algorithm ignores the
+          trigger
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.control.aeRegions">
+            <td class="entry_name">android.<wbr>control.<wbr>ae<wbr>Regions</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  5 x area_count
+                </span>
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              List of areas to use for
+          metering
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              Each area is a rectangle plus weight: xmin,<wbr> ymin,<wbr>
+          xmax,<wbr> ymax,<wbr> weight.<wbr> The coordinate system is based on the
+          active pixel array,<wbr> with (0,<wbr>0) being the top-left of the
+          active pixel array,<wbr> and
+          (android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>width,<wbr>
+          android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>height) being the
+          bottom-right point of the active pixel array.<wbr> The weight
+          should be nonnegative.<wbr> If all regions have 0 weight,<wbr> then
+          no specific metering area needs to be used by the HAL.<wbr> If
+          the metering region is outside the current
+          android.<wbr>scaler.<wbr>crop<wbr>Region,<wbr> the HAL should ignore the
+          sections outside the region and output the used sections
+          in the frame metadata
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.control.aeState">
+            <td class="entry_name">android.<wbr>control.<wbr>ae<wbr>State</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">INACTIVE</span>
+                    <span class="entry_type_enum_notes">AE is off</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">SEARCHING</span>
+                    <span class="entry_type_enum_notes">AE doesn't yet have a good set of control values
+            for the current scene</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">CONVERGED</span>
+                    <span class="entry_type_enum_notes">AE has a good set of control values for the
+            current scene</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">LOCKED</span>
+                    <span class="entry_type_enum_notes">AE has been locked (aeMode =
+            LOCKED)</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">FLASH_REQUIRED</span>
+                    <span class="entry_type_enum_notes">AE has a good set of control values,<wbr> but flash
+            needs to be fired for good quality still
+            capture</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">PRECAPTURE</span>
+                    <span class="entry_type_enum_notes">AE has been asked to do a precapture sequence
+            (through the
+            trigger_<wbr>action(CAMERA2_<wbr>TRIGGER_<wbr>PRECAPTURE_<wbr>METERING)
+            call),<wbr> and is currently executing it.<wbr> Once PRECAPTURE
+            completes,<wbr> AE will transition to CONVERGED or
+            FLASH_<wbr>REQUIRED as appropriate</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Current state of AE algorithm
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              Whenever the AE algorithm state changes,<wbr> a
+          MSG_<wbr>AUTOEXPOSURE notification must be send if a
+          notification callback is registered.<wbr>
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.control.afMode">
+            <td class="entry_name">android.<wbr>control.<wbr>af<wbr>Mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">OFF</span>
+                    <span class="entry_type_enum_notes">The 3A routines do not control the lens;
+            android.<wbr>lens.<wbr>focus<wbr>Position is controlled by the
+            application</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">AUTO</span>
+                    <span class="entry_type_enum_notes">if lens is not fixed focus.<wbr> Use
+            android.<wbr>lens.<wbr>minimum<wbr>Focus<wbr>Distance to determine if lens
+            is fixed focus In this mode,<wbr> the lens does not move
+            unless the autofocus trigger action is called.<wbr> When
+            that trigger is activated,<wbr> AF must transition to
+            ACTIVE_<wbr>SCAN,<wbr> then to the outcome of the scan (FOCUSED
+            or NOT_<wbr>FOCUSED).<wbr> Triggering cancel AF resets the lens
+            position to default,<wbr> and sets the AF state to
+            INACTIVE.<wbr></span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">MACRO</span>
+                    <span class="entry_type_enum_notes">In this mode,<wbr> the lens does not move unless the
+            autofocus trigger action is called.<wbr> When that trigger
+            is activated,<wbr> AF must transition to ACTIVE_<wbr>SCAN,<wbr> then
+            to the outcome of the scan (FOCUSED or NOT_<wbr>FOCUSED).<wbr>
+            Triggering cancel AF resets the lens position to
+            default,<wbr> and sets the AF state to
+            INACTIVE.<wbr></span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">CONTINUOUS_VIDEO</span>
+                    <span class="entry_type_enum_notes">In this mode,<wbr> the AF algorithm modifies the lens
+            position continually to attempt to provide a
+            constantly-in-focus image stream.<wbr> The focusing behavior
+            should be suitable for good quality video recording;
+            typically this means slower focus movement and no
+            overshoots.<wbr> When the AF trigger is not involved,<wbr> the AF
+            algorithm should start in INACTIVE state,<wbr> and then
+            transition into PASSIVE_<wbr>SCAN and PASSIVE_<wbr>FOCUSED states
+            as appropriate.<wbr> When the AF trigger is activated,<wbr> the
+            algorithm should immediately transition into AF_<wbr>FOCUSED
+            or AF_<wbr>NOT_<wbr>FOCUSED as appropriate,<wbr> and lock the lens
+            position until a cancel AF trigger is received.<wbr> Once
+            cancel is received,<wbr> the algorithm should transition
+            back to INACTIVE and resume passive scan.<wbr> Note that
+            this behavior is not identical to CONTINUOUS_<wbr>PICTURE,<wbr>
+            since an ongoing PASSIVE_<wbr>SCAN must immediately be
+            canceled.<wbr></span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">CONTINUOUS_PICTURE</span>
+                    <span class="entry_type_enum_notes">In this mode,<wbr> the AF algorithm modifies the lens
+            position continually to attempt to provide a
+            constantly-in-focus image stream.<wbr> The focusing behavior
+            should be suitable for still image capture; typically
+            this means focusing as fast as possible.<wbr> When the AF
+            trigger is not involved,<wbr> the AF algorithm should start
+            in INACTIVE state,<wbr> and then transition into
+            PASSIVE_<wbr>SCAN and PASSIVE_<wbr>FOCUSED states as appropriate
+            as it attempts to maintain focus.<wbr> When the AF trigger
+            is activated,<wbr> the algorithm should finish its
+            PASSIVE_<wbr>SCAN if active,<wbr> and then transition into
+            AF_<wbr>FOCUSED or AF_<wbr>NOT_<wbr>FOCUSED as appropriate,<wbr> and lock
+            the lens position until a cancel AF trigger is
+            received.<wbr> When the AF cancel trigger is activated,<wbr> the
+            algorithm should transition back to INACTIVE and then
+            act as if it has just been started.<wbr></span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">EDOF</span>
+                    <span class="entry_type_enum_notes">Extended depth of field (digital focus).<wbr> AF
+            trigger is ignored,<wbr> AF state should always be
+            INACTIVE.<wbr></span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Whether AF is currently enabled,<wbr> and what
+          mode it is set to
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.control.afRegions">
+            <td class="entry_name">android.<wbr>control.<wbr>af<wbr>Regions</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  5 x area_count
+                </span>
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              List of areas to use for focus
+          estimation
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              Each area is a rectangle plus weight: xmin,<wbr> ymin,<wbr>
+          xmax,<wbr> ymax,<wbr> weight.<wbr> The coordinate system is based on the
+          active pixel array,<wbr> with (0,<wbr>0) being the top-left of the
+          active pixel array,<wbr> and
+          (android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>width,<wbr>
+          android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>height) being the
+          bottom-right point of the active pixel array.<wbr> The weight
+          should be nonnegative.<wbr> If all regions have 0 weight,<wbr> then
+          no specific focus area needs to be used by the HAL.<wbr> If
+          the focusing region is outside the current
+          android.<wbr>scaler.<wbr>crop<wbr>Region,<wbr> the HAL should ignore the
+          sections outside the region and output the used sections
+          in the frame metadata
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.control.afState">
+            <td class="entry_name">android.<wbr>control.<wbr>af<wbr>State</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">INACTIVE</span>
+                    <span class="entry_type_enum_notes">AF off or has not yet tried to scan/<wbr>been asked
+            to scan</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">PASSIVE_SCAN</span>
+                    <span class="entry_type_enum_notes">if CONTINUOUS_<wbr>* modes are supported AF is
+            currently doing an AF scan initiated by a continuous
+            autofocus mode</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">PASSIVE_FOCUSED</span>
+                    <span class="entry_type_enum_notes">if CONTINUOUS_<wbr>* modes are supported AF currently
+            believes it is in focus,<wbr> but may restart scanning at
+            any time.<wbr></span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">ACTIVE_SCAN</span>
+                    <span class="entry_type_enum_notes">if AUTO or MACRO modes are supported AF is doing
+            an AF scan because it was triggered by AF
+            trigger</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">FOCUSED_LOCKED</span>
+                    <span class="entry_type_enum_notes">if any AF mode besides OFF is supported AF
+            believes it is focused correctly and is
+            locked</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">NOT_FOCUSED_LOCKED</span>
+                    <span class="entry_type_enum_notes">if any AF mode besides OFF is supported AF has
+            failed to focus successfully and is
+            locked</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Current state of AF algorithm
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              Whenever the AF algorithm state changes,<wbr> a
+          MSG_<wbr>AUTOFOCUS notification must be send if a notification
+          callback is registered.<wbr>
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.control.afTriggerId">
+            <td class="entry_name">android.<wbr>control.<wbr>af<wbr>Trigger<wbr>Id</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              The ID sent with the latest
+          CAMERA2_<wbr>TRIGGER_<wbr>AUTOFOCUS call
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              Must be 0 if no CAMERA2_<wbr>TRIGGER_<wbr>AUTOFOCUS trigger
+          received yet by HAL.<wbr> Always updated even if AF algorithm
+          ignores the trigger
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.control.awbMode">
+            <td class="entry_name">android.<wbr>control.<wbr>awb<wbr>Mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">OFF</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">AUTO</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">INCANDESCENT</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">FLUORESCENT</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">WARM_FLUORESCENT</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">DAYLIGHT</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">CLOUDY_DAYLIGHT</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">TWILIGHT</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">SHADE</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Whether AWB is currently setting the color
+          transform fields,<wbr> and what its illumination target
+          is
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              [BC - AWB lock,<wbr>AWB modes]
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+                  <li><a href="#tag_AWB">AWB</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.control.awbRegions">
+            <td class="entry_name">android.<wbr>control.<wbr>awb<wbr>Regions</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  5 x area_count
+                </span>
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              List of areas to use for illuminant
+          estimation
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              Only used in AUTO mode.<wbr> Each area is a rectangle
+          plus weight: xmin,<wbr> ymin,<wbr> xmax,<wbr> ymax,<wbr> weight.<wbr> The
+          coordinate system is based on the active pixel array,<wbr>
+          with (0,<wbr>0) being the top-left of the active pixel array,<wbr>
+          and (android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>width,<wbr>
+          android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size.<wbr>height) being the
+          bottom-right point of the active pixel array.<wbr> The weight
+          should be nonnegative.<wbr> If all regions have 0 weight,<wbr> then
+          no specific metering area needs to be used by the HAL.<wbr> If
+          the metering region is outside the current
+          android.<wbr>scaler.<wbr>crop<wbr>Region,<wbr> the HAL should ignore the
+          sections outside the region and output the used sections
+          in the frame metadata
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.control.awbState">
+            <td class="entry_name">android.<wbr>control.<wbr>awb<wbr>State</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">INACTIVE</span>
+                    <span class="entry_type_enum_notes">AWB is not in auto mode</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">SEARCHING</span>
+                    <span class="entry_type_enum_notes">AWB doesn't yet have a good set of control
+            values for the current scene</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">CONVERGED</span>
+                    <span class="entry_type_enum_notes">AWB has a good set of control values for the
+            current scene</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">LOCKED</span>
+                    <span class="entry_type_enum_notes">AE has been locked (aeMode =
+            LOCKED)</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Current state of AWB algorithm
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              Whenever the AWB algorithm state changes,<wbr> a
+          MSG_<wbr>AUTOWHITEBALANCE notification must be send if a
+          notification callback is registered.<wbr>
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.control.mode">
+            <td class="entry_name">android.<wbr>control.<wbr>mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">OFF</span>
+                    <span class="entry_type_enum_notes">Full application control of pipeline.<wbr> All 3A
+            routines are disabled,<wbr> no other settings in
+            android.<wbr>control.<wbr>* have any effect</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">AUTO</span>
+                    <span class="entry_type_enum_notes">Use settings for each individual 3A routine.<wbr>
+            Manual control of capture parameters is disabled.<wbr> All
+            controls in android.<wbr>control.<wbr>* besides sceneMode take
+            effect</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">USE_SCENE_MODE</span>
+                    <span class="entry_type_enum_notes">Use specific scene mode.<wbr> Enabling this disables
+            control.<wbr>aeMode,<wbr> control.<wbr>awbMode and control.<wbr>afMode
+            controls; the HAL must ignore those settings while
+            USE_<wbr>SCENE_<wbr>MODE is active (except for FACE_<wbr>PRIORITY
+            scene mode).<wbr> Other control entries are still active.<wbr>
+            This setting can only be used if availableSceneModes !=
+            UNSUPPORTED</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Overall mode of 3A control
+          routines
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              all must be supported
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+
+  <!-- end of section -->
+  <tr><td colspan="7" id="section_demosaic" class="section">demosaic</td></tr>
+
+
+      <tr><td colspan="7" class="kind">controls</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="controls_android.demosaic.mode">
+            <td class="entry_name">android.<wbr>demosaic.<wbr>mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">FAST</span>
+                    <span class="entry_type_enum_notes">Minimal or no slowdown of frame rate compared to
+            Bayer RAW output</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">HIGH_QUALITY</span>
+                    <span class="entry_type_enum_notes">High-quality may reduce output frame
+            rate</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Controls the quality of the demosaicing
+          processing
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+
+  <!-- end of section -->
+  <tr><td colspan="7" id="section_edge" class="section">edge</td></tr>
+
+
+      <tr><td colspan="7" class="kind">controls</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="controls_android.edge.mode">
+            <td class="entry_name">android.<wbr>edge.<wbr>mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">OFF</span>
+                    <span class="entry_type_enum_notes">No edge enhancement is applied</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">FAST</span>
+                    <span class="entry_type_enum_notes">Must not slow down frame rate relative to raw
+            bayer output</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">HIGH_QUALITY</span>
+                    <span class="entry_type_enum_notes">Frame rate may be reduced by high
+            quality</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Operation mode for edge
+          enhancement
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.edge.strength">
+            <td class="entry_name">android.<wbr>edge.<wbr>strength</td>
+            <td class="entry_type">
+                <span class="entry_type_name">byte</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Control the amount of edge enhancement
+          applied to the images
+            </td>
+
+            <td class="entry_units">
+              1-10; 10 is maximum sharpening
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+      <tr><td colspan="7" class="kind">dynamic</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="dynamic_android.edge.mode">
+            <td class="entry_name">android.<wbr>edge.<wbr>mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">OFF</span>
+                    <span class="entry_type_enum_notes">No edge enhancement is applied</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">FAST</span>
+                    <span class="entry_type_enum_notes">Must not slow down frame rate relative to raw
+            bayer output</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">HIGH_QUALITY</span>
+                    <span class="entry_type_enum_notes">Frame rate may be reduced by high
+            quality</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Operation mode for edge
+          enhancement
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+
+  <!-- end of section -->
+  <tr><td colspan="7" id="section_flash" class="section">flash</td></tr>
+
+
+      <tr><td colspan="7" class="kind">controls</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="controls_android.flash.firingPower">
+            <td class="entry_name">android.<wbr>flash.<wbr>firing<wbr>Power</td>
+            <td class="entry_type">
+                <span class="entry_type_name">byte</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Power for flash firing/<wbr>torch
+            </td>
+
+            <td class="entry_units">
+              10 is max power; 0 is no flash.<wbr> Linear
+            </td>
+
+            <td class="entry_range">
+              0 - 10
+            </td>
+
+            <td class="entry_notes">
+              Power for snapshot may use a different scale than
+          for torch mode.<wbr> Only one entry for torch mode will be
+          used
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.flash.firingTime">
+            <td class="entry_name">android.<wbr>flash.<wbr>firing<wbr>Time</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int64</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Firing time of flash relative to start of
+          exposure
+            </td>
+
+            <td class="entry_units">
+              nanoseconds
+            </td>
+
+            <td class="entry_range">
+              0-(exposure time-flash duration)
+            </td>
+
+            <td class="entry_notes">
+              Clamped to (0,<wbr> exposure time - flash
+          duration).<wbr>
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.flash.mode">
+            <td class="entry_name">android.<wbr>flash.<wbr>mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">OFF</span>
+                    <span class="entry_type_enum_notes">Do not fire the flash for this
+            capture</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">SINGLE</span>
+                    <span class="entry_type_enum_notes">if android.<wbr>flash.<wbr>available is true Fire flash
+            for this capture based on firingPower,<wbr>
+            firingTime.<wbr></span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">TORCH</span>
+                    <span class="entry_type_enum_notes">if android.<wbr>flash.<wbr>available is true Flash
+            continuously on,<wbr> power set by
+            firingPower</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Select flash operation mode
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+      <tr><td colspan="7" class="kind">static</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+                
+            
+
+                
+          <tr class="entry" id="static_android.flash.info.available">
+            <td class="entry_name">android.<wbr>flash.<wbr>info.<wbr>available</td>
+            <td class="entry_type">
+                <span class="entry_type_name">byte</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Whether this camera has a
+            flash
+            </td>
+
+            <td class="entry_units">
+              boolean (0 = false,<wbr> otherwise true)
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              If no flash,<wbr> none of the flash controls do
+            anything.<wbr> All other metadata should return 0
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.flash.info.chargeDuration">
+            <td class="entry_name">android.<wbr>flash.<wbr>info.<wbr>charge<wbr>Duration</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int64</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Time taken before flash can fire
+            again
+            </td>
+
+            <td class="entry_units">
+              nanoseconds
+            </td>
+
+            <td class="entry_range">
+              0-1e9
+            </td>
+
+            <td class="entry_notes">
+              1 second too long/<wbr>too short for recharge? Should
+            this be power-dependent?
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+        
+
+                
+          <tr class="entry" id="static_android.flash.colorTemperature">
+            <td class="entry_name">android.<wbr>flash.<wbr>color<wbr>Temperature</td>
+            <td class="entry_type">
+                <span class="entry_type_name">byte</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              The x,<wbr>y whitepoint of the
+          flash
+            </td>
+
+            <td class="entry_units">
+              pair of floats
+            </td>
+
+            <td class="entry_range">
+              0-1 for both
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_ADV">ADV</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.flash.maxEnergy">
+            <td class="entry_name">android.<wbr>flash.<wbr>max<wbr>Energy</td>
+            <td class="entry_type">
+                <span class="entry_type_name">byte</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Max energy output of the flash for a full
+          power single flash
+            </td>
+
+            <td class="entry_units">
+              lumen-seconds
+            </td>
+
+            <td class="entry_range">
+              >= 0
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_ADV">ADV</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+      <tr><td colspan="7" class="kind">dynamic</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="dynamic_android.flash.firingPower">
+            <td class="entry_name">android.<wbr>flash.<wbr>firing<wbr>Power</td>
+            <td class="entry_type">
+                <span class="entry_type_name">byte</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Power for flash firing/<wbr>torch
+            </td>
+
+            <td class="entry_units">
+              10 is max power; 0 is no flash.<wbr> Linear
+            </td>
+
+            <td class="entry_range">
+              0 - 10
+            </td>
+
+            <td class="entry_notes">
+              Power for snapshot may use a different scale than
+          for torch mode.<wbr> Only one entry for torch mode will be
+          used
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.flash.firingTime">
+            <td class="entry_name">android.<wbr>flash.<wbr>firing<wbr>Time</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int64</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Firing time of flash relative to start of
+          exposure
+            </td>
+
+            <td class="entry_units">
+              nanoseconds
+            </td>
+
+            <td class="entry_range">
+              0-(exposure time-flash duration)
+            </td>
+
+            <td class="entry_notes">
+              Clamped to (0,<wbr> exposure time - flash
+          duration).<wbr>
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.flash.mode">
+            <td class="entry_name">android.<wbr>flash.<wbr>mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">OFF</span>
+                    <span class="entry_type_enum_notes">Do not fire the flash for this
+            capture</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">SINGLE</span>
+                    <span class="entry_type_enum_notes">if android.<wbr>flash.<wbr>available is true Fire flash
+            for this capture based on firingPower,<wbr>
+            firingTime.<wbr></span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">TORCH</span>
+                    <span class="entry_type_enum_notes">if android.<wbr>flash.<wbr>available is true Flash
+            continuously on,<wbr> power set by
+            firingPower</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Select flash operation mode
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.flash.state">
+            <td class="entry_name">android.<wbr>flash.<wbr>state</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">UNAVAILABLE</span>
+                    <span class="entry_type_enum_notes">No flash on camera</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">CHARGING</span>
+                    <span class="entry_type_enum_notes">if android.<wbr>flash.<wbr>available is true Flash is
+            charging and cannot be fired</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">READY</span>
+                    <span class="entry_type_enum_notes">if android.<wbr>flash.<wbr>available is true Flash is
+            ready to fire</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">FIRED</span>
+                    <span class="entry_type_enum_notes">if android.<wbr>flash.<wbr>available is true Flash fired
+            for this capture</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Current state of the flash
+          unit
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+
+  <!-- end of section -->
+  <tr><td colspan="7" id="section_geometric" class="section">geometric</td></tr>
+
+
+      <tr><td colspan="7" class="kind">controls</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="controls_android.geometric.mode">
+            <td class="entry_name">android.<wbr>geometric.<wbr>mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">OFF</span>
+                    <span class="entry_type_enum_notes">No geometric correction is
+            applied</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">FAST</span>
+                    <span class="entry_type_enum_notes">Must not slow down frame rate relative to raw
+            bayer output</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">HIGH_QUALITY</span>
+                    <span class="entry_type_enum_notes">Frame rate may be reduced by high
+            quality</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Operating mode of geometric
+          correction
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.geometric.strength">
+            <td class="entry_name">android.<wbr>geometric.<wbr>strength</td>
+            <td class="entry_type">
+                <span class="entry_type_name">byte</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Control the amount of shading correction
+          applied to the images
+            </td>
+
+            <td class="entry_units">
+              unitless: 1-10; 10 is full shading
+          compensation
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_ADV">ADV</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+
+  <!-- end of section -->
+  <tr><td colspan="7" id="section_hotPixel" class="section">hotPixel</td></tr>
+
+
+      <tr><td colspan="7" class="kind">controls</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="controls_android.hotPixel.mode">
+            <td class="entry_name">android.<wbr>hot<wbr>Pixel.<wbr>mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">OFF</span>
+                    <span class="entry_type_enum_notes">No hot pixel correction can be
+            applied</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">FAST</span>
+                    <span class="entry_type_enum_notes">Frame rate must not be reduced compared to raw
+            Bayer output</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">HIGH_QUALITY</span>
+                    <span class="entry_type_enum_notes">Frame rate may be reduced by high
+            quality</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Set operational mode for hot pixel
+          correction
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+      <tr><td colspan="7" class="kind">static</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+                
+            
+
+                
+          <tr class="entry" id="static_android.hotPixel.info.map">
+            <td class="entry_name">android.<wbr>hot<wbr>Pixel.<wbr>info.<wbr>map</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  2 x n
+                </span>
+
+                <div class="entry_type_notes">list of coordinates based on android.<wbr>sensor.<wbr>pixel<wbr>Array<wbr>Size</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Location of hot/<wbr>defective pixels on
+            sensor
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_ADV">ADV</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+        
+
+        
+
+      <!-- end of kind -->
+      </tbody>
+      <tr><td colspan="7" class="kind">dynamic</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="dynamic_android.hotPixel.mode">
+            <td class="entry_name">android.<wbr>hot<wbr>Pixel.<wbr>mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">OFF</span>
+                    <span class="entry_type_enum_notes">No hot pixel correction can be
+            applied</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">FAST</span>
+                    <span class="entry_type_enum_notes">Frame rate must not be reduced compared to raw
+            Bayer output</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">HIGH_QUALITY</span>
+                    <span class="entry_type_enum_notes">Frame rate may be reduced by high
+            quality</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Set operational mode for hot pixel
+          correction
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+
+  <!-- end of section -->
+  <tr><td colspan="7" id="section_jpeg" class="section">jpeg</td></tr>
+
+
+      <tr><td colspan="7" class="kind">controls</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="controls_android.jpeg.gpsCoordinates">
+            <td class="entry_name">android.<wbr>jpeg.<wbr>gps<wbr>Coordinates</td>
+            <td class="entry_type">
+                <span class="entry_type_name">double</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  3
+                </span>
+
+                <div class="entry_type_notes">latitude,<wbr> longitude,<wbr> altitude.<wbr> First two in degrees,<wbr> the third in meters</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              GPS coordinates to include in output JPEG
+          EXIF
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              (-180 - 180],<wbr> [-90,<wbr>90],<wbr> [-inf,<wbr> inf]
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.jpeg.gpsProcessingMethod">
+            <td class="entry_name">android.<wbr>jpeg.<wbr>gps<wbr>Processing<wbr>Method</td>
+            <td class="entry_type">
+                <span class="entry_type_name">byte</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              32 characters describing GPS algorithm to
+          include in EXIF
+            </td>
+
+            <td class="entry_units">
+              UTF-8 null-terminated string
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.jpeg.gpsTimestamp">
+            <td class="entry_name">android.<wbr>jpeg.<wbr>gps<wbr>Timestamp</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int64</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Time GPS fix was made to include in
+          EXIF
+            </td>
+
+            <td class="entry_units">
+              UTC in seconds since January 1,<wbr> 1970
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.jpeg.orientation">
+            <td class="entry_name">android.<wbr>jpeg.<wbr>orientation</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Orientation of JPEG image to
+          write
+            </td>
+
+            <td class="entry_units">
+              Degrees in multiples of 90
+            </td>
+
+            <td class="entry_range">
+              0,<wbr> 90,<wbr> 180,<wbr> 270
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.jpeg.quality">
+            <td class="entry_name">android.<wbr>jpeg.<wbr>quality</td>
+            <td class="entry_type">
+                <span class="entry_type_name">byte</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Compression quality of the final JPEG
+          image
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              1-100; larger is higher quality
+            </td>
+
+            <td class="entry_notes">
+              85-95 is typical usage range
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.jpeg.thumbnailQuality">
+            <td class="entry_name">android.<wbr>jpeg.<wbr>thumbnail<wbr>Quality</td>
+            <td class="entry_type">
+                <span class="entry_type_name">byte</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Compression quality of JPEG
+          thumbnail
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              1-100; larger is higher quality
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.jpeg.thumbnailSize">
+            <td class="entry_name">android.<wbr>jpeg.<wbr>thumbnail<wbr>Size</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  2
+                </span>
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Resolution of embedded JPEG
+          thumbnail
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              from android.<wbr>jpeg.<wbr>available<wbr>Thumbnail<wbr>Sizes
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+      <tr><td colspan="7" class="kind">static</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="static_android.jpeg.availableThumbnailSizes">
+            <td class="entry_name">android.<wbr>jpeg.<wbr>available<wbr>Thumbnail<wbr>Sizes</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  2 x n
+                </span>
+
+                <div class="entry_type_notes">list of resolution pairs</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Supported resolutions for the JPEG
+          thumbnail
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              Must include at least one valid resolution,<wbr> plus
+          (0,<wbr>0) for no thumbnail generation
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.jpeg.maxSize">
+            <td class="entry_name">android.<wbr>jpeg.<wbr>max<wbr>Size</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Maximum size in bytes for the compressed
+          JPEG buffer
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              Must be large enough to fit any JPEG produced by
+          the camera
+            </td>
+
+            <td class="entry_notes">
+              This is used for sizing the gralloc buffers for
+          JPEG
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+      <tr><td colspan="7" class="kind">dynamic</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="dynamic_android.jpeg.gpsCoordinates">
+            <td class="entry_name">android.<wbr>jpeg.<wbr>gps<wbr>Coordinates</td>
+            <td class="entry_type">
+                <span class="entry_type_name">double</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  3
+                </span>
+
+                <div class="entry_type_notes">latitude,<wbr> longitude,<wbr> altitude.<wbr> First two in degrees,<wbr> the third in meters</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              GPS coordinates to include in output JPEG
+          EXIF
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              (-180 - 180],<wbr> [-90,<wbr>90],<wbr> [-inf,<wbr> inf]
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.jpeg.gpsProcessingMethod">
+            <td class="entry_name">android.<wbr>jpeg.<wbr>gps<wbr>Processing<wbr>Method</td>
+            <td class="entry_type">
+                <span class="entry_type_name">byte</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              32 characters describing GPS algorithm to
+          include in EXIF
+            </td>
+
+            <td class="entry_units">
+              UTF-8 null-terminated string
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.jpeg.gpsTimestamp">
+            <td class="entry_name">android.<wbr>jpeg.<wbr>gps<wbr>Timestamp</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int64</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Time GPS fix was made to include in
+          EXIF
+            </td>
+
+            <td class="entry_units">
+              UTC in seconds since January 1,<wbr> 1970
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.jpeg.orientation">
+            <td class="entry_name">android.<wbr>jpeg.<wbr>orientation</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Orientation of JPEG image to
+          write
+            </td>
+
+            <td class="entry_units">
+              Degrees in multiples of 90
+            </td>
+
+            <td class="entry_range">
+              0,<wbr> 90,<wbr> 180,<wbr> 270
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.jpeg.quality">
+            <td class="entry_name">android.<wbr>jpeg.<wbr>quality</td>
+            <td class="entry_type">
+                <span class="entry_type_name">byte</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Compression quality of the final JPEG
+          image
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              1-100; larger is higher quality
+            </td>
+
+            <td class="entry_notes">
+              85-95 is typical usage range
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.jpeg.size">
+            <td class="entry_name">android.<wbr>jpeg.<wbr>size</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              The size of the compressed JPEG image,<wbr> in
+          bytes
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              >= 0
+            </td>
+
+            <td class="entry_notes">
+              If no JPEG output is produced for the request,<wbr>
+          this must be 0.<wbr> Otherwise,<wbr> this describes the real size
+          of the compressed JPEG image placed in the output stream.<wbr>
+          More specifically,<wbr> if android.<wbr>jpeg.<wbr>max<wbr>Size = 1000000,<wbr> and
+          a specific capture has android.<wbr>jpeg.<wbr>size = 500000,<wbr> then
+          the output buffer from the JPEG stream will be 1000000
+          bytes,<wbr> of which the first 500000 make up the real
+          data.<wbr>
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.jpeg.thumbnailQuality">
+            <td class="entry_name">android.<wbr>jpeg.<wbr>thumbnail<wbr>Quality</td>
+            <td class="entry_type">
+                <span class="entry_type_name">byte</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Compression quality of JPEG
+          thumbnail
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              1-100; larger is higher quality
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.jpeg.thumbnailSize">
+            <td class="entry_name">android.<wbr>jpeg.<wbr>thumbnail<wbr>Size</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  2
+                </span>
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Resolution of embedded JPEG
+          thumbnail
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              from android.<wbr>jpeg.<wbr>available<wbr>Thumbnail<wbr>Sizes
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+
+  <!-- end of section -->
+  <tr><td colspan="7" id="section_lens" class="section">lens</td></tr>
+
+
+      <tr><td colspan="7" class="kind">controls</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="controls_android.lens.aperture">
+            <td class="entry_name">android.<wbr>lens.<wbr>aperture</td>
+            <td class="entry_type">
+                <span class="entry_type_name">float</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Size of the lens aperture
+            </td>
+
+            <td class="entry_units">
+              f-number (f/<wbr>NNN)
+            </td>
+
+            <td class="entry_range">
+              android.<wbr>lens.<wbr>info.<wbr>available<wbr>Apertures
+            </td>
+
+            <td class="entry_notes">
+              Will not be supported on most devices.<wbr> Can only
+          pick from supported list
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.lens.filterDensity">
+            <td class="entry_name">android.<wbr>lens.<wbr>filter<wbr>Density</td>
+            <td class="entry_type">
+                <span class="entry_type_name">float</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              State of lens neutral density
+          filter(s)
+            </td>
+
+            <td class="entry_units">
+              number of stops of filtering
+            </td>
+
+            <td class="entry_range">
+              android.<wbr>lens.<wbr>info.<wbr>available<wbr>Filter<wbr>Densities
+            </td>
+
+            <td class="entry_notes">
+              Will not be supported on most devices.<wbr> Can only
+          pick from supported list
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.lens.focalLength">
+            <td class="entry_name">android.<wbr>lens.<wbr>focal<wbr>Length</td>
+            <td class="entry_type">
+                <span class="entry_type_name">float</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Lens optical zoom setting
+            </td>
+
+            <td class="entry_units">
+              focal length in mm
+            </td>
+
+            <td class="entry_range">
+              > 0
+            </td>
+
+            <td class="entry_notes">
+              Will not be supported on most devices.<wbr>
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.lens.focusDistance">
+            <td class="entry_name">android.<wbr>lens.<wbr>focus<wbr>Distance</td>
+            <td class="entry_type">
+                <span class="entry_type_name">float</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Distance to plane of sharpest focus,<wbr>
+          measured from frontmost surface of the lens
+            </td>
+
+            <td class="entry_units">
+              diopters (1/<wbr>m)
+            </td>
+
+            <td class="entry_range">
+              >= 0
+            </td>
+
+            <td class="entry_notes">
+              0 = infinity focus.<wbr> Used value should be clamped
+          to (0,<wbr>minimum focus distance)
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.lens.opticalStabilizationMode">
+            <td class="entry_name">android.<wbr>lens.<wbr>optical<wbr>Stabilization<wbr>Mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">OFF</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">ON</span>
+                    <span class="entry_type_enum_optional">optional</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Whether optical image stabilization is
+          enabled.<wbr>
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              android.<wbr>lens.<wbr>available<wbr>Optical<wbr>Stabilization
+            </td>
+
+            <td class="entry_notes">
+              Will not be supported on most devices.<wbr>
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+      <tr><td colspan="7" class="kind">static</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+                
+            
+
+                
+          <tr class="entry" id="static_android.lens.info.availableApertures">
+            <td class="entry_name">android.<wbr>lens.<wbr>info.<wbr>available<wbr>Apertures</td>
+            <td class="entry_type">
+                <span class="entry_type_name">float</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  n
+                </span>
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              List of supported aperture
+            values
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              one entry required,<wbr> > 0
+            </td>
+
+            <td class="entry_notes">
+              If variable aperture not available,<wbr> only setting
+            should be for the fixed aperture
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.lens.info.availableFilterDensities">
+            <td class="entry_name">android.<wbr>lens.<wbr>info.<wbr>available<wbr>Filter<wbr>Densities</td>
+            <td class="entry_type">
+                <span class="entry_type_name">float</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  n
+                </span>
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              List of supported ND filter
+            values
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              one entry required,<wbr> >= 0
+            </td>
+
+            <td class="entry_notes">
+              If not available,<wbr> only setting is 0.<wbr> Otherwise,<wbr>
+            lists the available exposure index values for dimming
+            (2 would mean the filter is set to reduce incoming
+            light by two stops)
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.lens.info.availableFocalLengths">
+            <td class="entry_name">android.<wbr>lens.<wbr>info.<wbr>available<wbr>Focal<wbr>Lengths</td>
+            <td class="entry_type">
+                <span class="entry_type_name">float</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  n
+                </span>
+
+                <div class="entry_type_notes">the list of available focal lengths</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              If fitted with optical zoom,<wbr> what focal
+            lengths are available.<wbr> If not,<wbr> the static focal
+            length
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              > 0
+            </td>
+
+            <td class="entry_notes">
+              If optical zoom not supported,<wbr> only one value
+            should be reported
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.lens.info.availableOpticalStabilization">
+            <td class="entry_name">android.<wbr>lens.<wbr>info.<wbr>available<wbr>Optical<wbr>Stabilization</td>
+            <td class="entry_type">
+                <span class="entry_type_name">byte</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  n
+                </span>
+
+                <div class="entry_type_notes">list of enums</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              List of supported optical image
+            stabilization modes
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.lens.info.geometricCorrectionMap">
+            <td class="entry_name">android.<wbr>lens.<wbr>info.<wbr>geometric<wbr>Correction<wbr>Map</td>
+            <td class="entry_type">
+                <span class="entry_type_name">float</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  2 x 3 x n x m
+                </span>
+
+                <div class="entry_type_notes">2D array of destination coordinate pairs for uniform grid points in source image,<wbr> per color channel.<wbr> Size in the range of 2x3x40x30</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              A low-resolution map for correction of
+            geometric distortions and chromatic aberrations,<wbr> per
+            color channel
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              N,<wbr> M >= 2
+            </td>
+
+            <td class="entry_notes">
+              [DNG wants a function instead].<wbr> What's easiest
+            for implementers? With an array size (M,<wbr> N),<wbr> entry (i,<wbr>
+            j) provides the destination for pixel (i/<wbr>(M-1) * width,<wbr>
+            j/<wbr>(N-1) * height).<wbr> Data is row-major,<wbr> with each array
+            entry being ( (X,<wbr> Y)_<wbr>r,<wbr> (X,<wbr> Y)_<wbr>g,<wbr> (X,<wbr> Y)_<wbr>b ) )
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_DNG">DNG</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.lens.info.geometricCorrectionMapSize">
+            <td class="entry_name">android.<wbr>lens.<wbr>info.<wbr>geometric<wbr>Correction<wbr>Map<wbr>Size</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  2
+                </span>
+
+                <div class="entry_type_notes">width and height of geometric correction map</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Dimensions of geometric correction
+            map
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              Both values >= 2
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.lens.info.hyperfocalDistance">
+            <td class="entry_name">android.<wbr>lens.<wbr>info.<wbr>hyperfocal<wbr>Distance</td>
+            <td class="entry_type">
+                <span class="entry_type_name">float</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Hyperfocal distance for this lens; set to
+            0 if fixed focus
+            </td>
+
+            <td class="entry_units">
+              diopters
+            </td>
+
+            <td class="entry_range">
+              >= 0
+            </td>
+
+            <td class="entry_notes">
+              The hyperfocal distance is used for the old
+            API's 'fixed' setting
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.lens.info.minimumFocusDistance">
+            <td class="entry_name">android.<wbr>lens.<wbr>info.<wbr>minimum<wbr>Focus<wbr>Distance</td>
+            <td class="entry_type">
+                <span class="entry_type_name">float</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Shortest distance from frontmost surface
+            of the lens that can be focused correctly
+            </td>
+
+            <td class="entry_units">
+              diopters
+            </td>
+
+            <td class="entry_range">
+              >= 0
+            </td>
+
+            <td class="entry_notes">
+              If the lens is fixed-focus,<wbr> this should be
+            0
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.lens.info.shadingMap">
+            <td class="entry_name">android.<wbr>lens.<wbr>info.<wbr>shading<wbr>Map</td>
+            <td class="entry_type">
+                <span class="entry_type_name">float</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  3 x n x m
+                </span>
+
+                <div class="entry_type_notes">2D array of float gain factors per channel to correct for lens falloff.<wbr> Should be on the order of 3x40x30</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              A low-resolution map of lens shading,<wbr> per
+            color channel
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              Each gain factor is >= 1
+            </td>
+
+            <td class="entry_notes">
+              Assume bilinear interpolation of map.<wbr> The least
+            shaded section of the image should have a gain factor
+            of 1; all other sections should have gains above
+            1.<wbr>
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_DNG">DNG</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.lens.info.shadingMapSize">
+            <td class="entry_name">android.<wbr>lens.<wbr>info.<wbr>shading<wbr>Map<wbr>Size</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  2
+                </span>
+
+                <div class="entry_type_notes">width and height of lens shading map</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Dimensions of lens shading
+            map
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              Both values >= 1
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+        
+
+                
+          <tr class="entry" id="static_android.lens.facing">
+            <td class="entry_name">android.<wbr>lens.<wbr>facing</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">FRONT</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">BACK</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Direction the camera faces relative to
+          device screen
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.lens.opticalAxisAngle">
+            <td class="entry_name">android.<wbr>lens.<wbr>optical<wbr>Axis<wbr>Angle</td>
+            <td class="entry_type">
+                <span class="entry_type_name">float</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  2
+                </span>
+
+                <div class="entry_type_notes">degrees.<wbr> First defines the angle of separation between the perpendicular to the screen and the camera optical axis.<wbr> The second then defines the clockwise rotation of the optical axis from native device up.<wbr></div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Relative angle of camera optical axis to the
+          perpendicular axis from the display
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              [0-90) for first angle,<wbr> [0-360) for second
+            </td>
+
+            <td class="entry_notes">
+              Examples: (0,<wbr>0) means that the camera optical axis
+          is perpendicular to the display surface; (45,<wbr>0) means
+          that the camera points 45 degrees up when device is held
+          upright; (45,<wbr>90) means the camera points 45 degrees to
+          the right when the device is held upright.<wbr> Use FACING
+          field to determine perpendicular outgoing
+          direction
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_ADV">ADV</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.lens.position">
+            <td class="entry_name">android.<wbr>lens.<wbr>position</td>
+            <td class="entry_type">
+                <span class="entry_type_name">float</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  3, location in mm, in the sensor coordinate
+            system
+                </span>
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Coordinates of camera optical axis on
+          device
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+      <tr><td colspan="7" class="kind">dynamic</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="dynamic_android.lens.aperture">
+            <td class="entry_name">android.<wbr>lens.<wbr>aperture</td>
+            <td class="entry_type">
+                <span class="entry_type_name">float</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Size of the lens aperture
+            </td>
+
+            <td class="entry_units">
+              f-number (f/<wbr>NNN)
+            </td>
+
+            <td class="entry_range">
+              android.<wbr>lens.<wbr>info.<wbr>available<wbr>Apertures
+            </td>
+
+            <td class="entry_notes">
+              Will not be supported on most devices.<wbr> Can only
+          pick from supported list
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.lens.filterDensity">
+            <td class="entry_name">android.<wbr>lens.<wbr>filter<wbr>Density</td>
+            <td class="entry_type">
+                <span class="entry_type_name">float</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              State of lens neutral density
+          filter(s)
+            </td>
+
+            <td class="entry_units">
+              number of stops of filtering
+            </td>
+
+            <td class="entry_range">
+              android.<wbr>lens.<wbr>info.<wbr>available<wbr>Filter<wbr>Densities
+            </td>
+
+            <td class="entry_notes">
+              Will not be supported on most devices.<wbr> Can only
+          pick from supported list
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.lens.focalLength">
+            <td class="entry_name">android.<wbr>lens.<wbr>focal<wbr>Length</td>
+            <td class="entry_type">
+                <span class="entry_type_name">float</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Lens optical zoom setting
+            </td>
+
+            <td class="entry_units">
+              focal length in mm
+            </td>
+
+            <td class="entry_range">
+              > 0
+            </td>
+
+            <td class="entry_notes">
+              Will not be supported on most devices.<wbr>
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.lens.focusDistance">
+            <td class="entry_name">android.<wbr>lens.<wbr>focus<wbr>Distance</td>
+            <td class="entry_type">
+                <span class="entry_type_name">float</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Distance to plane of sharpest focus,<wbr>
+          measured from frontmost surface of the lens
+            </td>
+
+            <td class="entry_units">
+              diopters (1/<wbr>m)
+            </td>
+
+            <td class="entry_range">
+              >= 0
+            </td>
+
+            <td class="entry_notes">
+              Should be zero for fixed-focus cameras
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.lens.focusRange">
+            <td class="entry_name">android.<wbr>lens.<wbr>focus<wbr>Range</td>
+            <td class="entry_type">
+                <span class="entry_type_name">float</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              The range of scene distances that are in
+          sharp focus (depth of field)
+            </td>
+
+            <td class="entry_units">
+              pair of focus distances in diopters: (near,<wbr>
+          far)
+            </td>
+
+            <td class="entry_range">
+              >=0
+            </td>
+
+            <td class="entry_notes">
+              If variable focus not supported,<wbr> can still report
+          fixed depth of field range
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.lens.opticalStabilizationMode">
+            <td class="entry_name">android.<wbr>lens.<wbr>optical<wbr>Stabilization<wbr>Mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">OFF</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">ON</span>
+                    <span class="entry_type_enum_optional">optional</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Whether optical image stabilization is
+          enabled.<wbr>
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              android.<wbr>lens.<wbr>available<wbr>Optical<wbr>Stabilization
+            </td>
+
+            <td class="entry_notes">
+              Will not be supported on most devices.<wbr>
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.lens.state">
+            <td class="entry_name">android.<wbr>lens.<wbr>state</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">STATIONARY</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Current lens status
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+
+  <!-- end of section -->
+  <tr><td colspan="7" id="section_noiseReduction" class="section">noiseReduction</td></tr>
+
+
+      <tr><td colspan="7" class="kind">controls</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="controls_android.noiseReduction.mode">
+            <td class="entry_name">android.<wbr>noise<wbr>Reduction.<wbr>mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">OFF</span>
+                    <span class="entry_type_enum_notes">No noise reduction is applied</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">FAST</span>
+                    <span class="entry_type_enum_notes">Must not slow down frame rate relative to raw
+            bayer output</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">HIGH_QUALITY</span>
+                    <span class="entry_type_enum_notes">May slow down frame rate to provide highest
+            quality</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Mode of operation for the noise reduction
+          algorithm
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              android.<wbr>noise<wbr>Reduction.<wbr>available<wbr>Modes
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.noiseReduction.strength">
+            <td class="entry_name">android.<wbr>noise<wbr>Reduction.<wbr>strength</td>
+            <td class="entry_type">
+                <span class="entry_type_name">byte</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Control the amount of noise reduction
+          applied to the images
+            </td>
+
+            <td class="entry_units">
+              1-10; 10 is max noise reduction
+            </td>
+
+            <td class="entry_range">
+              1 - 10
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+      <tr><td colspan="7" class="kind">dynamic</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="dynamic_android.noiseReduction.mode">
+            <td class="entry_name">android.<wbr>noise<wbr>Reduction.<wbr>mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">OFF</span>
+                    <span class="entry_type_enum_notes">No noise reduction is applied</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">FAST</span>
+                    <span class="entry_type_enum_notes">Must not slow down frame rate relative to raw
+            bayer output</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">HIGH_QUALITY</span>
+                    <span class="entry_type_enum_notes">May slow down frame rate to provide highest
+            quality</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Mode of operation for the noise reduction
+          algorithm
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              android.<wbr>noise<wbr>Reduction.<wbr>available<wbr>Modes
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+
+  <!-- end of section -->
+  <tr><td colspan="7" id="section_quirks" class="section">quirks</td></tr>
+
+
+      <tr><td colspan="7" class="kind">static</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="static_android.quirks.meteringCropRegion">
+            <td class="entry_name">android.<wbr>quirks.<wbr>metering<wbr>Crop<wbr>Region</td>
+            <td class="entry_type">
+                <span class="entry_type_name">byte</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              If set to 1,<wbr> the camera service does not
+          scale 'normalized' coordinates with respect to the crop
+          region.<wbr> This applies to metering input (a{e,<wbr>f,<wbr>wb}Region
+          and output (face rectangles).<wbr>
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              Normalized coordinates refer to those in the
+          (-1000,<wbr>1000) range mentioned in the
+          android.<wbr>hardware.<wbr><wbr>Camera API.<wbr> HAL implementations should
+          instead always use and emit sensor array-relative
+          coordinates for all region data.<wbr> Does not need to be
+          listed in static metadata.<wbr> Support will be removed in
+          future versions of camera service.<wbr>
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.quirks.triggerAfWithAuto">
+            <td class="entry_name">android.<wbr>quirks.<wbr>trigger<wbr>Af<wbr>With<wbr>Auto</td>
+            <td class="entry_type">
+                <span class="entry_type_name">byte</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              If set to 1,<wbr> then the camera service always
+          switches to FOCUS_<wbr>MODE_<wbr>AUTO before issuing a AF
+          trigger.<wbr>
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              HAL implementations should implement AF trigger
+          modes for AUTO,<wbr> MACRO,<wbr> CONTINUOUS_<wbr>FOCUS,<wbr> and
+          CONTINUOUS_<wbr>PICTURE modes instead of using this flag.<wbr> Does
+          not need to be listed in static metadata.<wbr> Support will be
+          removed in future versions of camera service
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.quirks.useZslFormat">
+            <td class="entry_name">android.<wbr>quirks.<wbr>use<wbr>Zsl<wbr>Format</td>
+            <td class="entry_type">
+                <span class="entry_type_name">byte</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              If set to 1,<wbr> the camera service uses
+          CAMERA2_<wbr>PIXEL_<wbr>FORMAT_<wbr>ZSL instead of
+          HAL_<wbr>PIXEL_<wbr>FORMAT_<wbr>IMPLEMENTATION_<wbr>DEFINED for the zero
+          shutter lag stream
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              HAL implementations should use gralloc usage flags
+          to determine that a stream will be used for
+          zero-shutter-lag,<wbr> instead of relying on an explicit
+          format setting.<wbr> Does not need to be listed in static
+          metadata.<wbr> Support will be removed in future versions of
+          camera service.<wbr>
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+
+  <!-- end of section -->
+  <tr><td colspan="7" id="section_request" class="section">request</td></tr>
+
+
+      <tr><td colspan="7" class="kind">controls</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="controls_android.request.frameCount">
+            <td class="entry_name">android.<wbr>request.<wbr>frame<wbr>Count</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              A frame counter set by the framework.<wbr> Must
+          be maintained unchanged in output frame
+            </td>
+
+            <td class="entry_units">
+              incrementing integer
+            </td>
+
+            <td class="entry_range">
+              Any int
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.request.id">
+            <td class="entry_name">android.<wbr>request.<wbr>id</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              An application-specified ID for the current
+          request.<wbr> Must be maintained unchanged in output
+          frame
+            </td>
+
+            <td class="entry_units">
+              arbitrary integer assigned by application
+            </td>
+
+            <td class="entry_range">
+              Any int
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.request.inputStreams">
+            <td class="entry_name">android.<wbr>request.<wbr>input<wbr>Streams</td>
+            <td class="entry_type">
+                <span class="entry_type_name">byte</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              List which camera reprocess stream is used
+          for the source of reprocessing data.<wbr>
+            </td>
+
+            <td class="entry_units">
+              List of camera reprocess stream IDs
+            </td>
+
+            <td class="entry_range">
+              Typically,<wbr> only one entry allowed,<wbr> must be a valid
+          reprocess stream ID.<wbr> If android.<wbr>jpeg.<wbr>needs<wbr>Thumbnail is
+          set,<wbr> then multiple reprocess streams may be included in a
+          single request; they must be different scaled versions of
+          the same image.<wbr>
+            </td>
+
+            <td class="entry_notes">
+              Only meaningful when android.<wbr>request.<wbr>type ==
+          REPROCESS.<wbr> Ignored otherwise
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.request.metadataMode">
+            <td class="entry_name">android.<wbr>request.<wbr>metadata<wbr>Mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">NONE</span>
+                    <span class="entry_type_enum_notes">No metadata should be produced on output,<wbr> except
+            for application-bound buffer data.<wbr> If no
+            application-bound streams exist,<wbr> no frame should be
+            placed in the output frame queue.<wbr> If such streams
+            exist,<wbr> a frame should be placed on the output queue
+            with null metadata but with the necessary output buffer
+            information.<wbr> Timestamp information should still be
+            included with any output stream buffers</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">FULL</span>
+                    <span class="entry_type_enum_notes">All metadata should be produced.<wbr> Statistics will
+            only be produced if they are separately
+            enabled</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              How much metadata to produce on
+          output
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.request.outputStreams">
+            <td class="entry_name">android.<wbr>request.<wbr>output<wbr>Streams</td>
+            <td class="entry_type">
+                <span class="entry_type_name">byte</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Lists which camera output streams image data
+          from this capture must be sent to
+            </td>
+
+            <td class="entry_units">
+              List of camera stream IDs
+            </td>
+
+            <td class="entry_range">
+              List must only include streams that have been
+          created
+            </td>
+
+            <td class="entry_notes">
+              If no output streams are listed,<wbr> then the image
+          data should simply be discarded.<wbr> The image data must
+          still be captured for metadata and statistics production,<wbr>
+          and the lens and flash must operate as requested.<wbr>
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.request.type">
+            <td class="entry_name">android.<wbr>request.<wbr>type</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">CAPTURE</span>
+                    <span class="entry_type_enum_notes">Capture a new image from the imaging hardware,<wbr>
+            and process it according to the
+            settings</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">REPROCESS</span>
+                    <span class="entry_type_enum_notes">Process previously captured data; the
+            android.<wbr>request.<wbr>input<wbr>Stream parameter determines the
+            source reprocessing stream.<wbr> TODO: Mark dynamic metadata
+            needed for reprocessing with [RP]</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              The type of the request; either CAPTURE or
+          REPROCESS
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+      <tr><td colspan="7" class="kind">static</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="static_android.request.maxNumOutputStreams">
+            <td class="entry_name">android.<wbr>request.<wbr>max<wbr>Num<wbr>Output<wbr>Streams</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  3
+                </span>
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              How many output streams can be allocated at
+          the same time for each type of stream
+            </td>
+
+            <td class="entry_units">
+              The number of raw sensor streams; the number of
+          processed,<wbr> uncompressed streams; and the number of
+          JPEG-compressed streams
+            </td>
+
+            <td class="entry_range">
+              >=1 for Raw and JPEG-compressed stream.<wbr> >= 3
+          for processed,<wbr> uncompressed streams
+            </td>
+
+            <td class="entry_notes">
+              Video snapshot with preview callbacks requires 3
+          processed streams (preview,<wbr> record,<wbr> app callbacks) and
+          one JPEG stream (snapshot)
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.request.maxNumReprocessStreams">
+            <td class="entry_name">android.<wbr>request.<wbr>max<wbr>Num<wbr>Reprocess<wbr>Streams</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  1
+                </span>
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              How many reprocessing streams of any type
+          can be allocated at the same time
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              >= 1
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+      <tr><td colspan="7" class="kind">dynamic</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="dynamic_android.request.frameCount">
+            <td class="entry_name">android.<wbr>request.<wbr>frame<wbr>Count</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Number of frames captured since
+          open()
+            </td>
+
+            <td class="entry_units">
+              count of frames
+            </td>
+
+            <td class="entry_range">
+              > 0
+            </td>
+
+            <td class="entry_notes">
+              Reset on release()
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.request.id">
+            <td class="entry_name">android.<wbr>request.<wbr>id</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              An application-specified ID for the current
+          request.<wbr> Must be maintained unchanged in output
+          frame
+            </td>
+
+            <td class="entry_units">
+              arbitrary integer assigned by application
+            </td>
+
+            <td class="entry_range">
+              Any int
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.request.metadataMode">
+            <td class="entry_name">android.<wbr>request.<wbr>metadata<wbr>Mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">NONE</span>
+                    <span class="entry_type_enum_notes">No metadata should be produced on output,<wbr> except
+            for application-bound buffer data.<wbr> If no
+            application-bound streams exist,<wbr> no frame should be
+            placed in the output frame queue.<wbr> If such streams
+            exist,<wbr> a frame should be placed on the output queue
+            with null metadata but with the necessary output buffer
+            information.<wbr> Timestamp information should still be
+            included with any output stream buffers</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">FULL</span>
+                    <span class="entry_type_enum_notes">All metadata should be produced.<wbr> Statistics will
+            only be produced if they are separately
+            enabled</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              How much metadata to produce on
+          output
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.request.outputStreams">
+            <td class="entry_name">android.<wbr>request.<wbr>output<wbr>Streams</td>
+            <td class="entry_type">
+                <span class="entry_type_name">byte</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Lists which camera output streams image data
+          from this capture must be sent to
+            </td>
+
+            <td class="entry_units">
+              List of camera stream IDs
+            </td>
+
+            <td class="entry_range">
+              List must only include streams that have been
+          created
+            </td>
+
+            <td class="entry_notes">
+              If no output streams are listed,<wbr> then the image
+          data should simply be discarded.<wbr> The image data must
+          still be captured for metadata and statistics production,<wbr>
+          and the lens and flash must operate as requested.<wbr>
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+
+  <!-- end of section -->
+  <tr><td colspan="7" id="section_scaler" class="section">scaler</td></tr>
+
+
+      <tr><td colspan="7" class="kind">controls</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="controls_android.scaler.cropRegion">
+            <td class="entry_name">android.<wbr>scaler.<wbr>crop<wbr>Region</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  3
+                </span>
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Top-left corner and width of the output
+          region to select from the active pixel
+          array
+            </td>
+
+            <td class="entry_units">
+              (x,<wbr>y) of top-left corner,<wbr> width of region in
+          pixels; (0,<wbr>0) is top-left corner of
+          android.<wbr>sensor.<wbr>active<wbr>Pixel<wbr>Array
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              [BC - zoom] Height determined based on width and
+          aspect ratio of output stream.<wbr> Negative values for corner
+          are allowed for raw output if full pixel array is larger
+          than active pixel array.<wbr> Width may be rounded to nearest
+          larger supportable width,<wbr> especially for raw output,<wbr>
+          where only a few fixed scales may be possible
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+      <tr><td colspan="7" class="kind">static</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="static_android.scaler.availableFormats">
+            <td class="entry_name">android.<wbr>scaler.<wbr>available<wbr>Formats</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">int32</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  n
+                </span>
+
+                <div class="entry_type_notes">values from HAL_<wbr>PIXEL_<wbr>FORMAT_<wbr>* in /<wbr>system/<wbr>core/<wbr>include/<wbr>system/<wbr>graphics.<wbr>h</div>
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">RAW_SENSOR</span>
+                    <span class="entry_type_enum_value">0x20</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">YV12</span>
+                    <span class="entry_type_enum_value">0x32315659</span>
+                    <span class="entry_type_enum_notes">YCrCb 4:2:0 Planar</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">YCbCr_420_SP</span>
+                    <span class="entry_type_enum_value">0x11</span>
+                    <span class="entry_type_enum_notes">NV21</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">JPEG</span>
+                    <span class="entry_type_enum_value">0x21</span>
+                    <span class="entry_type_enum_notes">BLOB</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              List of app-visible formats
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.scaler.availableJpegMinDurations">
+            <td class="entry_name">android.<wbr>scaler.<wbr>available<wbr>Jpeg<wbr>Min<wbr>Durations</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int64</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  n
+                </span>
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              The minimum frame duration that is supported
+          for each resolution in availableJpegSizes.<wbr> Should
+          correspond to the frame duration when only that JPEG
+          stream is active,<wbr> with all processing set to
+          FAST
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              When multiple streams are configured,<wbr> the minimum
+          frame duration will be >= max(individual stream min
+          durations)
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.scaler.availableJpegSizes">
+            <td class="entry_name">android.<wbr>scaler.<wbr>available<wbr>Jpeg<wbr>Sizes</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  n x 2
+                </span>
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              The resolutions available for output from
+          the JPEG block.<wbr> Listed as width x height
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              Must include: - sensor maximum resolution Should
+          include: - half/<wbr>quarter max resolution
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.scaler.availableMaxDigitalZoom">
+            <td class="entry_name">android.<wbr>scaler.<wbr>available<wbr>Max<wbr>Digital<wbr>Zoom</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              TODO: have a real description here
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.scaler.availableProcessedMinDurations">
+            <td class="entry_name">android.<wbr>scaler.<wbr>available<wbr>Processed<wbr>Min<wbr>Durations</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int64</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  n
+                </span>
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              The minimum frame duration that is supported
+          for each resolution in availableProcessedSizes.<wbr> Should
+          correspond to the frame duration when only that processed
+          stream is active,<wbr> with all processing set to
+          FAST
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              When multiple streams are configured,<wbr> the minimum
+          frame duration will be >= max(individual stream min
+          durations)
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.scaler.availableProcessedSizes">
+            <td class="entry_name">android.<wbr>scaler.<wbr>available<wbr>Processed<wbr>Sizes</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  n x 2
+                </span>
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              The resolutions available for use with
+          processed output streams,<wbr> such as YV12,<wbr> NV12,<wbr> and
+          platform opaque YUV/<wbr>RGB streams to the GPU or video
+          encoders.<wbr> Listed as width,<wbr> height
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              Must include: - sensor maximum resolution -
+          standard QCIF,<wbr> 240p,<wbr> 480p,<wbr> 720p,<wbr> and 1080p
+          resolutions
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.scaler.availableRawMinDurations">
+            <td class="entry_name">android.<wbr>scaler.<wbr>available<wbr>Raw<wbr>Min<wbr>Durations</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int64</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  n
+                </span>
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              The minimum frame duration that is supported
+          for each raw resolution in availableRawSizes.<wbr> Should
+          correspond to the frame duration when only the raw stream
+          is active.<wbr>
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              When multiple streams are configured,<wbr> the minimum
+          frame duration will be >= max(individual stream min
+          durations)
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.scaler.availableRawSizes">
+            <td class="entry_name">android.<wbr>scaler.<wbr>available<wbr>Raw<wbr>Sizes</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  n x 2
+                </span>
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              The resolutions available for use with raw
+          sensor output streams,<wbr> listed as width,<wbr>
+          height
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              Must include: - sensor maximum resolution
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.scaler.maxDigitalZoom">
+            <td class="entry_name">android.<wbr>scaler.<wbr>max<wbr>Digital<wbr>Zoom</td>
+            <td class="entry_type">
+                <span class="entry_type_name">float</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              The maximum ratio between active area width
+          and crop region width,<wbr> or between active area height and
+          crop region height,<wbr> if the crop region height is larger
+          than width
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              >=1
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+      <tr><td colspan="7" class="kind">dynamic</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="dynamic_android.scaler.cropRegion">
+            <td class="entry_name">android.<wbr>scaler.<wbr>crop<wbr>Region</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  3
+                </span>
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Top-left corner and width of the output
+          region to select from the active pixel
+          array
+            </td>
+
+            <td class="entry_units">
+              (x,<wbr>y) of top-left corner,<wbr> width of region in
+          pixels; (0,<wbr>0) is top-left corner of
+          android.<wbr>sensor.<wbr>active<wbr>Pixel<wbr>Array
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              [BC - zoom] Height determined based on width and
+          aspect ratio of output stream.<wbr> Negative values for corner
+          are allowed for raw output if full pixel array is larger
+          than active pixel array.<wbr> Width may be rounded to nearest
+          larger supportable width,<wbr> especially for raw output,<wbr>
+          where only a few fixed scales may be possible
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+
+  <!-- end of section -->
+  <tr><td colspan="7" id="section_sensor" class="section">sensor</td></tr>
+
+
+      <tr><td colspan="7" class="kind">controls</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="controls_android.sensor.exposureTime">
+            <td class="entry_name">android.<wbr>sensor.<wbr>exposure<wbr>Time</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int64</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Duration each pixel is exposed to
+          light
+            </td>
+
+            <td class="entry_units">
+              nanoseconds
+            </td>
+
+            <td class="entry_range">
+              android.<wbr>sensor.<wbr>info.<wbr>exposure<wbr>Time<wbr>Range
+            </td>
+
+            <td class="entry_notes">
+              1/<wbr>10000 - 30 sec range.<wbr> No bulb mode
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.sensor.frameDuration">
+            <td class="entry_name">android.<wbr>sensor.<wbr>frame<wbr>Duration</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int64</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Duration from start of frame exposure to
+          start of next frame exposure
+            </td>
+
+            <td class="entry_units">
+              nanoseconds
+            </td>
+
+            <td class="entry_range">
+              see android.<wbr>sensor.<wbr>info.<wbr>max<wbr>Frame<wbr>Duration,<wbr>
+          android.<wbr>scaler.<wbr>info.<wbr>available<wbr>Min<wbr>Frame<wbr>Durations
+            </td>
+
+            <td class="entry_notes">
+              Exposure time has priority,<wbr> so duration is set to
+          max(duration,<wbr> exposure time + overhead)
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.sensor.sensitivity">
+            <td class="entry_name">android.<wbr>sensor.<wbr>sensitivity</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Gain applied to image data.<wbr> Must be
+          implemented through analog gain only if set to values
+          below 'maximum analog sensitivity'.<wbr>
+            </td>
+
+            <td class="entry_units">
+              ISO arithmetic units
+            </td>
+
+            <td class="entry_range">
+              android.<wbr>sensor.<wbr>info.<wbr>sensitivity<wbr>Range
+            </td>
+
+            <td class="entry_notes">
+              ISO 12232:2006 REI method
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+      <tr><td colspan="7" class="kind">static</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+                
+            
+
+                
+          <tr class="entry" id="static_android.sensor.info.activeArraySize">
+            <td class="entry_name">android.<wbr>sensor.<wbr>info.<wbr>active<wbr>Array<wbr>Size</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  4
+                </span>
+
+                <div class="entry_type_notes">Four ints defining the active pixel rectangle</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Area of raw data which corresponds to only
+            active pixels; smaller or equal to
+            pixelArraySize.<wbr>
+            </td>
+
+            <td class="entry_units">
+              xmin,<wbr> ymin,<wbr> width,<wbr> height.<wbr> Top left of full
+            pixel array is (0,<wbr>0)
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_DNG">DNG</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.sensor.info.availableSensitivities">
+            <td class="entry_name">android.<wbr>sensor.<wbr>info.<wbr>available<wbr>Sensitivities</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  n
+                </span>
+
+                <div class="entry_type_notes">List of supported sensitivity values</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Range of valid sensitivities
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              Must at least include 100,<wbr> 200,<wbr> 400,<wbr> 800,<wbr>
+            1600
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.sensor.info.colorFilterArrangement">
+            <td class="entry_name">android.<wbr>sensor.<wbr>info.<wbr>color<wbr>Filter<wbr>Arrangement</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">RGGB</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">GRBG</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">GBRG</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">BGGR</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">RGB</span>
+                    <span class="entry_type_enum_notes">Sensor is not Bayer; output has 3 16-bit
+              values for each pixel,<wbr> instead of just 1 16-bit value
+              per pixel.<wbr></span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Arrangement of color filters on sensor;
+            represents the colors in the top-left 2x2 section of
+            the sensor,<wbr> in reading order
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_DNG">DNG</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.sensor.info.exposureTimeRange">
+            <td class="entry_name">android.<wbr>sensor.<wbr>info.<wbr>exposure<wbr>Time<wbr>Range</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int64</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  2
+                </span>
+
+                <div class="entry_type_notes">nanoseconds</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Range of valid exposure
+            times
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              Min <= 100e3 (100 us),<wbr> Max >= 30e9 (30
+            sec)
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.sensor.info.maxFrameDuration">
+            <td class="entry_name">android.<wbr>sensor.<wbr>info.<wbr>max<wbr>Frame<wbr>Duration</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int64</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Maximum frame duration (minimum frame
+            rate)
+            </td>
+
+            <td class="entry_units">
+              nanoseconds
+            </td>
+
+            <td class="entry_range">
+              >= 30e9
+            </td>
+
+            <td class="entry_notes">
+              Minimum duration is a function of resolution,<wbr>
+            processing settings.<wbr> See
+            android.<wbr>scaler.<wbr>info.<wbr>available<wbr>Min<wbr>Frame<wbr>Durations
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.sensor.info.physicalSize">
+            <td class="entry_name">android.<wbr>sensor.<wbr>info.<wbr>physical<wbr>Size</td>
+            <td class="entry_type">
+                <span class="entry_type_name">float</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  2
+                </span>
+
+                <div class="entry_type_notes">width x height in millimeters</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              The physical dimensions of the full pixel
+            array
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              Needed for FOV calculation for old API
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.sensor.info.pixelArraySize">
+            <td class="entry_name">android.<wbr>sensor.<wbr>info.<wbr>pixel<wbr>Array<wbr>Size</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  2
+                </span>
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Dimensions of full pixel array,<wbr> possibly
+            including black calibration pixels
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              Maximum output resolution for raw format must
+            match this in
+            android.<wbr>scaler.<wbr>info.<wbr>available<wbr>Sizes<wbr>Per<wbr>Format
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_DNG">DNG</a></li>
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.sensor.info.whiteLevel">
+            <td class="entry_name">android.<wbr>sensor.<wbr>info.<wbr>white<wbr>Level</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Maximum raw value output by
+            sensor
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              > 1024 (10-bit output)
+            </td>
+
+            <td class="entry_notes">
+              Defines sensor bit depth (10-14 bits is
+            expected)
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_DNG">DNG</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+        
+
+                
+          <tr class="entry" id="static_android.sensor.baseGainFactor">
+            <td class="entry_name">android.<wbr>sensor.<wbr>base<wbr>Gain<wbr>Factor</td>
+            <td class="entry_type">
+                <span class="entry_type_name">rational</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Gain factor from electrons to raw units when
+          ISO=100
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.sensor.blackLevelPattern">
+            <td class="entry_name">android.<wbr>sensor.<wbr>black<wbr>Level<wbr>Pattern</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  4
+                </span>
+
+                <div class="entry_type_notes">2x2 raw count block</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              A fixed black level offset for each of the
+          Bayer mosaic channels
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              >= 0 each
+            </td>
+
+            <td class="entry_notes">
+              As per DNG BlackLevelRepeatDim /<wbr> BlackLevel
+          tags
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_DNG">DNG</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.sensor.calibrationTransform1">
+            <td class="entry_name">android.<wbr>sensor.<wbr>calibration<wbr>Transform1</td>
+            <td class="entry_type">
+                <span class="entry_type_name">rational</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  9
+                </span>
+
+                <div class="entry_type_notes">3x3 matrix in row-major-order</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Per-device calibration on top of color space
+          transform 1
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_DNG">DNG</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.sensor.calibrationTransform2">
+            <td class="entry_name">android.<wbr>sensor.<wbr>calibration<wbr>Transform2</td>
+            <td class="entry_type">
+                <span class="entry_type_name">rational</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  9
+                </span>
+
+                <div class="entry_type_notes">3x3 matrix in row-major-order</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Per-device calibration on top of color space
+          transform 2
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_DNG">DNG</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.sensor.colorTransform1">
+            <td class="entry_name">android.<wbr>sensor.<wbr>color<wbr>Transform1</td>
+            <td class="entry_type">
+                <span class="entry_type_name">rational</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  9
+                </span>
+
+                <div class="entry_type_notes">3x3 matrix in row-major-order</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Linear mapping from XYZ (D50) color space to
+          reference linear sensor color,<wbr> for first reference
+          illuminant
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              Use as follows XYZ = inv(transform) * clip( (raw -
+          black level(raw) ) /<wbr> ( white level - max black level) ).<wbr>
+          At least in the simple case
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_DNG">DNG</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.sensor.colorTransform2">
+            <td class="entry_name">android.<wbr>sensor.<wbr>color<wbr>Transform2</td>
+            <td class="entry_type">
+                <span class="entry_type_name">rational</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  9
+                </span>
+
+                <div class="entry_type_notes">3x3 matrix in row-major-order</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Linear mapping from XYZ (D50) color space to
+          reference linear sensor color,<wbr> for second reference
+          illuminant
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_DNG">DNG</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.sensor.forwardMatrix1">
+            <td class="entry_name">android.<wbr>sensor.<wbr>forward<wbr>Matrix1</td>
+            <td class="entry_type">
+                <span class="entry_type_name">rational</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  9
+                </span>
+
+                <div class="entry_type_notes">3x3 matrix in row-major-order</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Used by DNG for better WB
+          adaptation
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_DNG">DNG</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.sensor.forwardMatrix2">
+            <td class="entry_name">android.<wbr>sensor.<wbr>forward<wbr>Matrix2</td>
+            <td class="entry_type">
+                <span class="entry_type_name">rational</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  9
+                </span>
+
+                <div class="entry_type_notes">3x3 matrix in row-major-order</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Used by DNG for better WB
+          adaptation
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_DNG">DNG</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.sensor.maxAnalogSensitivity">
+            <td class="entry_name">android.<wbr>sensor.<wbr>max<wbr>Analog<wbr>Sensitivity</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Maximum sensitivity that is implemented
+          purely through analog gain
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              For android.<wbr>sensor.<wbr>sensitivity values less than or
+          equal to this,<wbr> all applied gain must be analog.<wbr> For
+          values above this,<wbr> it can be a mix of analog and
+          digital
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.sensor.noiseModelCoefficients">
+            <td class="entry_name">android.<wbr>sensor.<wbr>noise<wbr>Model<wbr>Coefficients</td>
+            <td class="entry_type">
+                <span class="entry_type_name">float</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  2
+                </span>
+
+                <div class="entry_type_notes">float constants A,<wbr> B for the noise variance model</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Estimation of sensor noise
+          characteristics
+            </td>
+
+            <td class="entry_units">
+              var(raw pixel value) = electrons * (baseGainFactor
+          * iso/<wbr>100)^2 + A * (baseGainFactor * iso/<wbr>100)^2 +
+          B
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              A represents sensor read noise before analog
+          amplification; B represents noise from A/<wbr>D conversion and
+          other circuits after amplification.<wbr> Both noise sources
+          are assumed to be gaussian,<wbr> independent,<wbr> and not to vary
+          across the sensor
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.sensor.orientation">
+            <td class="entry_name">android.<wbr>sensor.<wbr>orientation</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Clockwise angle through which the output
+          image needs to be rotated to be upright on the device
+          screen in its native orientation.<wbr> Also defines the
+          direction of rolling shutter readout,<wbr> which is from top
+          to bottom in the sensor's coordinate system
+            </td>
+
+            <td class="entry_units">
+              degrees clockwise rotation,<wbr> only multiples of
+          90
+            </td>
+
+            <td class="entry_range">
+              0,<wbr>90,<wbr>180,<wbr>270
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.sensor.referenceIlluminant1">
+            <td class="entry_name">android.<wbr>sensor.<wbr>reference<wbr>Illuminant1</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">DAYLIGHT</span>
+                    <span class="entry_type_enum_value">1</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">FLUORESCENT</span>
+                    <span class="entry_type_enum_value">2</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">TUNGSTEN</span>
+                    <span class="entry_type_enum_value">3</span>
+                    <span class="entry_type_enum_notes">Incandescent light</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">FLASH</span>
+                    <span class="entry_type_enum_value">4</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">FINE_WEATHER</span>
+                    <span class="entry_type_enum_value">9</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">CLOUDY_WEATHER</span>
+                    <span class="entry_type_enum_value">10</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">SHADE</span>
+                    <span class="entry_type_enum_value">11</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">DAYLIGHT_FLUORESCENT</span>
+                    <span class="entry_type_enum_value">12</span>
+                    <span class="entry_type_enum_notes">D 5700 - 7100K</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">DAY_WHITE_FLUORESCENT</span>
+                    <span class="entry_type_enum_value">13</span>
+                    <span class="entry_type_enum_notes">N 4600 - 5400K</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">COOL_WHITE_FLUORESCENT</span>
+                    <span class="entry_type_enum_value">14</span>
+                    <span class="entry_type_enum_notes">W 3900 - 4500K</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">WHITE_FLUORESCENT</span>
+                    <span class="entry_type_enum_value">15</span>
+                    <span class="entry_type_enum_notes">WW 3200 - 3700K</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">STANDARD_A</span>
+                    <span class="entry_type_enum_value">17</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">STANDARD_B</span>
+                    <span class="entry_type_enum_value">18</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">STANDARD_C</span>
+                    <span class="entry_type_enum_value">19</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">D55</span>
+                    <span class="entry_type_enum_value">20</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">D65</span>
+                    <span class="entry_type_enum_value">21</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">D75</span>
+                    <span class="entry_type_enum_value">22</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">D50</span>
+                    <span class="entry_type_enum_value">23</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">ISO_STUDIO_TUNGSTEN</span>
+                    <span class="entry_type_enum_value">24</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Light source used to define transform
+          1
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              [EXIF LightSource tag] Must all these be
+          supported? Need CCT for each!
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_DNG">DNG</a></li>
+                  <li><a href="#tag_EXIF">EXIF</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.sensor.referenceIlluminant2">
+            <td class="entry_name">android.<wbr>sensor.<wbr>reference<wbr>Illuminant2</td>
+            <td class="entry_type">
+                <span class="entry_type_name">byte</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Light source used to define transform
+          2
+            </td>
+
+            <td class="entry_units">
+              Same as illuminant 1
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+      <tr><td colspan="7" class="kind">dynamic</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="dynamic_android.sensor.exposureTime">
+            <td class="entry_name">android.<wbr>sensor.<wbr>exposure<wbr>Time</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int64</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Duration each pixel is exposed to
+          light
+            </td>
+
+            <td class="entry_units">
+              nanoseconds
+            </td>
+
+            <td class="entry_range">
+              android.<wbr>sensor.<wbr>info.<wbr>exposure<wbr>Time<wbr>Range
+            </td>
+
+            <td class="entry_notes">
+              1/<wbr>10000 - 30 sec range.<wbr> No bulb mode
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.sensor.frameDuration">
+            <td class="entry_name">android.<wbr>sensor.<wbr>frame<wbr>Duration</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int64</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Duration from start of frame exposure to
+          start of next frame exposure
+            </td>
+
+            <td class="entry_units">
+              nanoseconds
+            </td>
+
+            <td class="entry_range">
+              see android.<wbr>sensor.<wbr>info.<wbr>max<wbr>Frame<wbr>Duration,<wbr>
+          android.<wbr>scaler.<wbr>info.<wbr>available<wbr>Min<wbr>Frame<wbr>Durations
+            </td>
+
+            <td class="entry_notes">
+              Exposure time has priority,<wbr> so duration is set to
+          max(duration,<wbr> exposure time + overhead)
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.sensor.sensitivity">
+            <td class="entry_name">android.<wbr>sensor.<wbr>sensitivity</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Gain applied to image data.<wbr> Must be
+          implemented through analog gain only if set to values
+          below 'maximum analog sensitivity'.<wbr>
+            </td>
+
+            <td class="entry_units">
+              ISO arithmetic units
+            </td>
+
+            <td class="entry_range">
+              android.<wbr>sensor.<wbr>info.<wbr>sensitivity<wbr>Range
+            </td>
+
+            <td class="entry_notes">
+              ISO 12232:2006 REI method
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.sensor.timestamp">
+            <td class="entry_name">android.<wbr>sensor.<wbr>timestamp</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int64</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Time at start of exposure of first
+          row
+            </td>
+
+            <td class="entry_units">
+              nanoseconds
+            </td>
+
+            <td class="entry_range">
+              > 0
+            </td>
+
+            <td class="entry_notes">
+              Monotonic,<wbr> should be synced to other timestamps in
+          system
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+
+  <!-- end of section -->
+  <tr><td colspan="7" id="section_shading" class="section">shading</td></tr>
+
+
+      <tr><td colspan="7" class="kind">controls</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="controls_android.shading.mode">
+            <td class="entry_name">android.<wbr>shading.<wbr>mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">OFF</span>
+                    <span class="entry_type_enum_notes">No shading correction is applied</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">FAST</span>
+                    <span class="entry_type_enum_notes">Must not slow down frame rate relative to raw
+            bayer output</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">HIGH_QUALITY</span>
+                    <span class="entry_type_enum_notes">Frame rate may be reduced by high
+            quality</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Quality of lens shading correction applied
+          to the image data
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.shading.strength">
+            <td class="entry_name">android.<wbr>shading.<wbr>strength</td>
+            <td class="entry_type">
+                <span class="entry_type_name">byte</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Control the amount of shading correction
+          applied to the images
+            </td>
+
+            <td class="entry_units">
+              unitless: 1-10; 10 is full shading
+          compensation
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_ADV">ADV</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+      <tr><td colspan="7" class="kind">dynamic</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="dynamic_android.shading.mode">
+            <td class="entry_name">android.<wbr>shading.<wbr>mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">OFF</span>
+                    <span class="entry_type_enum_notes">No shading correction is applied</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">FAST</span>
+                    <span class="entry_type_enum_notes">Must not slow down frame rate relative to raw
+            bayer output</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">HIGH_QUALITY</span>
+                    <span class="entry_type_enum_notes">Frame rate may be reduced by high
+            quality</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Quality of lens shading correction applied
+          to the image data
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+
+  <!-- end of section -->
+  <tr><td colspan="7" id="section_statistics" class="section">statistics</td></tr>
+
+
+      <tr><td colspan="7" class="kind">controls</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="controls_android.statistics.faceDetectMode">
+            <td class="entry_name">android.<wbr>statistics.<wbr>face<wbr>Detect<wbr>Mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">OFF</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">SIMPLE</span>
+                    <span class="entry_type_enum_notes">Optional Return rectangle and confidence
+            only</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">FULL</span>
+                    <span class="entry_type_enum_notes">Optional Return all face
+            metadata</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              State of the face detector
+          unit
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              
+          android.<wbr>statistics.<wbr>available<wbr>Face<wbr>Detect<wbr>Modes
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.statistics.histogramMode">
+            <td class="entry_name">android.<wbr>statistics.<wbr>histogram<wbr>Mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">OFF</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">ON</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Operating mode for histogram
+          generation
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.statistics.sharpnessMapMode">
+            <td class="entry_name">android.<wbr>statistics.<wbr>sharpness<wbr>Map<wbr>Mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">OFF</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">ON</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Operating mode for sharpness map
+          generation
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+      <tr><td colspan="7" class="kind">static</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+                
+            
+
+                
+          <tr class="entry" id="static_android.statistics.info.availableFaceDetectModes">
+            <td class="entry_name">android.<wbr>statistics.<wbr>info.<wbr>available<wbr>Face<wbr>Detect<wbr>Modes</td>
+            <td class="entry_type">
+                <span class="entry_type_name">byte</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  n
+                </span>
+
+                <div class="entry_type_notes">List of enums</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Which face detection modes are available,<wbr>
+            if any
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              OFF
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.statistics.info.histogramBucketCount">
+            <td class="entry_name">android.<wbr>statistics.<wbr>info.<wbr>histogram<wbr>Bucket<wbr>Count</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Number of histogram buckets
+            supported
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              >= 64
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.statistics.info.maxFaceCount">
+            <td class="entry_name">android.<wbr>statistics.<wbr>info.<wbr>max<wbr>Face<wbr>Count</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              If face detection is supported,<wbr> how many
+            faces can be detected at once
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              >= 4 if availableFaceDetectionModes lists
+            modes besides OFF,<wbr> otherwise 0
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.statistics.info.maxHistogramCount">
+            <td class="entry_name">android.<wbr>statistics.<wbr>info.<wbr>max<wbr>Histogram<wbr>Count</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Maximum value possible for a histogram
+            bucket
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.statistics.info.maxSharpnessMapValue">
+            <td class="entry_name">android.<wbr>statistics.<wbr>info.<wbr>max<wbr>Sharpness<wbr>Map<wbr>Value</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Maximum value possible for a sharpness map
+            region.<wbr>
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="static_android.statistics.info.sharpnessMapSize">
+            <td class="entry_name">android.<wbr>statistics.<wbr>info.<wbr>sharpness<wbr>Map<wbr>Size</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  2
+                </span>
+
+                <div class="entry_type_notes">width x height</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Dimensions of the sharpness
+            map
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              Must be at least 32 x 32
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+        
+
+        
+
+      <!-- end of kind -->
+      </tbody>
+      <tr><td colspan="7" class="kind">dynamic</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="dynamic_android.statistics.faceDetectMode">
+            <td class="entry_name">android.<wbr>statistics.<wbr>face<wbr>Detect<wbr>Mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">OFF</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">SIMPLE</span>
+                    <span class="entry_type_enum_notes">Optional Return rectangle and confidence
+            only</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">FULL</span>
+                    <span class="entry_type_enum_notes">Optional Return all face
+            metadata</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              State of the face detector
+          unit
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              
+          android.<wbr>statistics.<wbr>available<wbr>Face<wbr>Detect<wbr>Modes
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.statistics.faceIds">
+            <td class="entry_name">android.<wbr>statistics.<wbr>face<wbr>Ids</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  n
+                </span>
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              List of unique IDs for detected
+          faces
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              Only available if faceDetectMode == FULL
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.statistics.faceLandmarks">
+            <td class="entry_name">android.<wbr>statistics.<wbr>face<wbr>Landmarks</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  n x 6
+                </span>
+
+                <div class="entry_type_notes">(leftEyeX,<wbr> leftEyeY,<wbr> rightEyeX,<wbr> rightEyeY,<wbr> mouthX,<wbr> mouthY)</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              List of landmarks for detected
+          faces
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              Only available if faceDetectMode == FULL
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.statistics.faceRectangles">
+            <td class="entry_name">android.<wbr>statistics.<wbr>face<wbr>Rectangles</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  n x 4
+                </span>
+
+                <div class="entry_type_notes">(xmin,<wbr> ymin,<wbr> xmax,<wbr> ymax).<wbr> (0,<wbr>0) is top-left of active pixel area</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              List of the bounding rectangles for detected
+          faces
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              Only available if faceDetectMode != OFF
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.statistics.faceScores">
+            <td class="entry_name">android.<wbr>statistics.<wbr>face<wbr>Scores</td>
+            <td class="entry_type">
+                <span class="entry_type_name">byte</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  n
+                </span>
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              List of the face confidence scores for
+          detected faces
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              0-100
+            </td>
+
+            <td class="entry_notes">
+              Only available if faceDetectMode != OFF
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_BC">BC</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.statistics.histogram">
+            <td class="entry_name">android.<wbr>statistics.<wbr>histogram</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  n x 3
+                </span>
+
+                <div class="entry_type_notes">count of pixels for each color channel that fall into each histogram bucket,<wbr> scaled to be between 0 and maxHistogramCount</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              A 3-channel histogram based on the raw
+          sensor data
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              The k'th bucket (0-based) covers the input range
+          (with w = android.<wbr>sensor.<wbr>info.<wbr>white<wbr>Level) of [ k * w/<wbr>N,<wbr>
+          (k + 1) * w /<wbr> N ).<wbr> If only a monochrome sharpness map is
+          supported,<wbr> all channels should have the same data
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.statistics.histogramMode">
+            <td class="entry_name">android.<wbr>statistics.<wbr>histogram<wbr>Mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">OFF</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">ON</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Operating mode for histogram
+          generation
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.statistics.sharpnessMap">
+            <td class="entry_name">android.<wbr>statistics.<wbr>sharpness<wbr>Map</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  n x m x 3
+                </span>
+
+                <div class="entry_type_notes">estimated sharpness for each region of the input image.<wbr> Normalized to be between 0 and maxSharpnessMapValue.<wbr> Higher values mean sharper (better focused)</div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              A 3-channel sharpness map,<wbr> based on the raw
+          sensor data
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+              If only a monochrome sharpness map is supported,<wbr>
+          all channels should have the same data
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.statistics.sharpnessMapMode">
+            <td class="entry_name">android.<wbr>statistics.<wbr>sharpness<wbr>Map<wbr>Mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">OFF</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">ON</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Operating mode for sharpness map
+          generation
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_V1">V1</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+
+  <!-- end of section -->
+  <tr><td colspan="7" id="section_tonemap" class="section">tonemap</td></tr>
+
+
+      <tr><td colspan="7" class="kind">controls</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="controls_android.tonemap.curveBlue">
+            <td class="entry_name">android.<wbr>tonemap.<wbr>curve<wbr>Blue</td>
+            <td class="entry_type">
+                <span class="entry_type_name">float</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Table mapping blue input values to output
+          values
+            </td>
+
+            <td class="entry_units">
+              same as android.<wbr>tonemap.<wbr>curve<wbr>Red
+            </td>
+
+            <td class="entry_range">
+              same as android.<wbr>tonemap.<wbr>curve<wbr>Red
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.tonemap.curveGreen">
+            <td class="entry_name">android.<wbr>tonemap.<wbr>curve<wbr>Green</td>
+            <td class="entry_type">
+                <span class="entry_type_name">float</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Table mapping green input values to output
+          values
+            </td>
+
+            <td class="entry_units">
+              same as android.<wbr>tonemap.<wbr>curve<wbr>Red
+            </td>
+
+            <td class="entry_range">
+              same as android.<wbr>tonemap.<wbr>curve<wbr>Red
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.tonemap.curveRed">
+            <td class="entry_name">android.<wbr>tonemap.<wbr>curve<wbr>Red</td>
+            <td class="entry_type">
+                <span class="entry_type_name">float</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  n x 2
+                </span>
+
+                <div class="entry_type_notes">A 1D array of pairs of floats.<wbr> mapping a 0-1 input range to a 0-1 output range.<wbr></div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Table mapping red input values to output
+          values
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              0-1 on input and output coordinates.<wbr> Max entry
+          count speciied by android.<wbr>tonemap.<wbr>max<wbr>Curve<wbr>Points
+            </td>
+
+            <td class="entry_notes">
+              .<wbr>The input range must be monotonically increasing
+          with N,<wbr> and values between entries should be linearly
+          interpolated.<wbr> For example,<wbr> if the array is: [0.<wbr>0,<wbr> 0.<wbr>0,<wbr>
+          0.<wbr>3,<wbr> 0.<wbr>5,<wbr> 1.<wbr>0,<wbr> 1.<wbr>0],<wbr> then the input->output mapping
+          for a few sample points would be: 0 -> 0,<wbr> 0.<wbr>15 ->
+          0.<wbr>25,<wbr> 0.<wbr>3 -> 0.<wbr>5,<wbr> 0.<wbr>5 -> 0.<wbr>64
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_DNG">DNG</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="controls_android.tonemap.mode">
+            <td class="entry_name">android.<wbr>tonemap.<wbr>mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">CONTRAST_CURVE</span>
+                    <span class="entry_type_enum_notes">Use the tone mapping curve specified in
+            android.<wbr>tonemap.<wbr>curve</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">FAST</span>
+                    <span class="entry_type_enum_notes">Must not slow down frame rate relative to raw
+            bayer output</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">HIGH_QUALITY</span>
+                    <span class="entry_type_enum_notes">Frame rate may be reduced by high
+            quality</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+      <tr><td colspan="7" class="kind">static</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="static_android.tonemap.maxCurvePoints">
+            <td class="entry_name">android.<wbr>tonemap.<wbr>max<wbr>Curve<wbr>Points</td>
+            <td class="entry_type">
+                <span class="entry_type_name">int32</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Maximum number of supported points in the
+          tonemap curve
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              >= 128
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+      <tr><td colspan="7" class="kind">dynamic</td></tr>
+
+      <thead>
+        <tr>
+          <th class="th_name">Property Name</th>
+          <th class="th_type">Type</th>
+          <th class="th_description">Description</th>
+          <th class="th_units">Units</th>
+          <th class="th_range">Range</th>
+          <th class="th_notes">Notes</th>
+          <th class="th_tags">Tags</th>
+        </tr>
+      </thead>
+
+      <tbody>
+
+        
+
+        
+
+        
+
+        
+
+                
+          <tr class="entry" id="dynamic_android.tonemap.curveBlue">
+            <td class="entry_name">android.<wbr>tonemap.<wbr>curve<wbr>Blue</td>
+            <td class="entry_type">
+                <span class="entry_type_name">float</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Table mapping blue input values to output
+          values
+            </td>
+
+            <td class="entry_units">
+              same as android.<wbr>tonemap.<wbr>curve<wbr>Red
+            </td>
+
+            <td class="entry_range">
+              same as android.<wbr>tonemap.<wbr>curve<wbr>Red
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.tonemap.curveGreen">
+            <td class="entry_name">android.<wbr>tonemap.<wbr>curve<wbr>Green</td>
+            <td class="entry_type">
+                <span class="entry_type_name">float</span>
+
+
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Table mapping green input values to output
+          values
+            </td>
+
+            <td class="entry_units">
+              same as android.<wbr>tonemap.<wbr>curve<wbr>Red
+            </td>
+
+            <td class="entry_range">
+              same as android.<wbr>tonemap.<wbr>curve<wbr>Red
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.tonemap.curveRed">
+            <td class="entry_name">android.<wbr>tonemap.<wbr>curve<wbr>Red</td>
+            <td class="entry_type">
+                <span class="entry_type_name">float</span>
+                <span class="entry_type_container">x</span>
+
+                <span class="entry_type_array">
+                  n x 2
+                </span>
+
+                <div class="entry_type_notes">A 1D array of pairs of floats.<wbr> mapping a 0-1 input range to a 0-1 output range.<wbr></div>
+
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+              Table mapping red input values to output
+          values
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+              0-1 on input and output coordinates.<wbr> Max entry
+          count speciied by android.<wbr>tonemap.<wbr>max<wbr>Curve<wbr>Points
+            </td>
+
+            <td class="entry_notes">
+              .<wbr>The input range must be monotonically increasing
+          with N,<wbr> and values between entries should be linearly
+          interpolated.<wbr> For example,<wbr> if the array is: [0.<wbr>0,<wbr> 0.<wbr>0,<wbr>
+          0.<wbr>3,<wbr> 0.<wbr>5,<wbr> 1.<wbr>0,<wbr> 1.<wbr>0],<wbr> then the input->output mapping
+          for a few sample points would be: 0 -> 0,<wbr> 0.<wbr>15 ->
+          0.<wbr>25,<wbr> 0.<wbr>3 -> 0.<wbr>5,<wbr> 0.<wbr>5 -> 0.<wbr>64
+            </td>
+
+            <td class="entry_tags">
+              <ul class="entry_tags">
+                  <li><a href="#tag_DNG">DNG</a></li>
+              </ul>
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+                
+          <tr class="entry" id="dynamic_android.tonemap.mode">
+            <td class="entry_name">android.<wbr>tonemap.<wbr>mode</td>
+            <td class="entry_type">
+                <span class="entry_type_name entry_type_name_enum">byte</span>
+
+
+
+                <ul class="entry_type_enum">
+                  <li>
+                    <span class="entry_type_enum_name">CONTRAST_CURVE</span>
+                    <span class="entry_type_enum_notes">Use the tone mapping curve specified in
+            android.<wbr>tonemap.<wbr>curve</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">FAST</span>
+                    <span class="entry_type_enum_notes">Must not slow down frame rate relative to raw
+            bayer output</span>
+                  </li>
+                  <li>
+                    <span class="entry_type_enum_name">HIGH_QUALITY</span>
+                    <span class="entry_type_enum_notes">Frame rate may be reduced by high
+            quality</span>
+                  </li>
+                </ul>
+
+            </td> <!-- entry_type -->
+
+            <td class="entry_description">
+            </td>
+
+            <td class="entry_units">
+            </td>
+
+            <td class="entry_range">
+            </td>
+
+            <td class="entry_notes">
+            </td>
+
+            <td class="entry_tags">
+            </td>
+
+          </tr> <!-- end of entry -->
+        
+        
+
+      <!-- end of kind -->
+      </tbody>
+
+  <!-- end of section -->
+<!-- </namespace> -->
+  </table>
+
+  <div class="tags" id="tag_index">
+    <h2>Tags</h2>
+    <ul>
+      <li id="tag_AWB">AWB - 
+        Needed for auto white balance
+    
+        <ul class="tags_entries">
+          <li><a href="#controls_android.control.awbMode">android.control.awbMode</a> (controls)</li>
+        </ul>
+      </li> <!-- tag_AWB -->
+      <li id="tag_BC">BC - 
+        Needed for backwards compatibility with old Java API
+    
+        <ul class="tags_entries">
+          <li><a href="#controls_android.control.aeExposureCompensation">android.control.aeExposureCompensation</a> (controls)</li>
+          <li><a href="#controls_android.control.aeLock">android.control.aeLock</a> (controls)</li>
+          <li><a href="#controls_android.control.aeMode">android.control.aeMode</a> (controls)</li>
+          <li><a href="#controls_android.control.aeRegions">android.control.aeRegions</a> (controls)</li>
+          <li><a href="#controls_android.control.aeTargetFpsRange">android.control.aeTargetFpsRange</a> (controls)</li>
+          <li><a href="#controls_android.control.afMode">android.control.afMode</a> (controls)</li>
+          <li><a href="#controls_android.control.afRegions">android.control.afRegions</a> (controls)</li>
+          <li><a href="#controls_android.control.awbLock">android.control.awbLock</a> (controls)</li>
+          <li><a href="#controls_android.control.awbMode">android.control.awbMode</a> (controls)</li>
+          <li><a href="#controls_android.control.awbRegions">android.control.awbRegions</a> (controls)</li>
+          <li><a href="#controls_android.control.captureIntent">android.control.captureIntent</a> (controls)</li>
+          <li><a href="#controls_android.control.effectMode">android.control.effectMode</a> (controls)</li>
+          <li><a href="#controls_android.control.mode">android.control.mode</a> (controls)</li>
+          <li><a href="#controls_android.control.sceneMode">android.control.sceneMode</a> (controls)</li>
+          <li><a href="#controls_android.control.videoStabilizationMode">android.control.videoStabilizationMode</a> (controls)</li>
+          <li><a href="#static_android.control.aeCompensationRange">android.control.aeCompensationRange</a> (static)</li>
+          <li><a href="#static_android.control.aeCompensationStep">android.control.aeCompensationStep</a> (static)</li>
+          <li><a href="#static_android.control.afAvailableModes">android.control.afAvailableModes</a> (static)</li>
+          <li><a href="#static_android.control.availableEffects">android.control.availableEffects</a> (static)</li>
+          <li><a href="#static_android.control.availableSceneModes">android.control.availableSceneModes</a> (static)</li>
+          <li><a href="#static_android.control.availableVideoStabilizationModes">android.control.availableVideoStabilizationModes</a> (static)</li>
+          <li><a href="#static_android.control.awbAvailableModes">android.control.awbAvailableModes</a> (static)</li>
+          <li><a href="#static_android.control.maxRegions">android.control.maxRegions</a> (static)</li>
+          <li><a href="#static_android.control.sceneModeOverrides">android.control.sceneModeOverrides</a> (static)</li>
+          <li><a href="#controls_android.flash.mode">android.flash.mode</a> (controls)</li>
+          <li><a href="#static_android.flash.info.available">android.flash.info.available</a> (static)</li>
+          <li><a href="#controls_android.jpeg.gpsCoordinates">android.jpeg.gpsCoordinates</a> (controls)</li>
+          <li><a href="#controls_android.jpeg.gpsProcessingMethod">android.jpeg.gpsProcessingMethod</a> (controls)</li>
+          <li><a href="#controls_android.jpeg.gpsTimestamp">android.jpeg.gpsTimestamp</a> (controls)</li>
+          <li><a href="#controls_android.jpeg.orientation">android.jpeg.orientation</a> (controls)</li>
+          <li><a href="#controls_android.jpeg.quality">android.jpeg.quality</a> (controls)</li>
+          <li><a href="#controls_android.jpeg.thumbnailQuality">android.jpeg.thumbnailQuality</a> (controls)</li>
+          <li><a href="#controls_android.jpeg.thumbnailSize">android.jpeg.thumbnailSize</a> (controls)</li>
+          <li><a href="#static_android.jpeg.availableThumbnailSizes">android.jpeg.availableThumbnailSizes</a> (static)</li>
+          <li><a href="#controls_android.lens.focusDistance">android.lens.focusDistance</a> (controls)</li>
+          <li><a href="#static_android.lens.info.availableFocalLengths">android.lens.info.availableFocalLengths</a> (static)</li>
+          <li><a href="#static_android.lens.info.hyperfocalDistance">android.lens.info.hyperfocalDistance</a> (static)</li>
+          <li><a href="#dynamic_android.lens.focusRange">android.lens.focusRange</a> (dynamic)</li>
+          <li><a href="#static_android.request.maxNumOutputStreams">android.request.maxNumOutputStreams</a> (static)</li>
+          <li><a href="#controls_android.scaler.cropRegion">android.scaler.cropRegion</a> (controls)</li>
+          <li><a href="#static_android.scaler.availableFormats">android.scaler.availableFormats</a> (static)</li>
+          <li><a href="#static_android.scaler.availableJpegMinDurations">android.scaler.availableJpegMinDurations</a> (static)</li>
+          <li><a href="#static_android.scaler.availableJpegSizes">android.scaler.availableJpegSizes</a> (static)</li>
+          <li><a href="#static_android.scaler.availableProcessedMinDurations">android.scaler.availableProcessedMinDurations</a> (static)</li>
+          <li><a href="#static_android.scaler.availableProcessedSizes">android.scaler.availableProcessedSizes</a> (static)</li>
+          <li><a href="#static_android.scaler.availableRawMinDurations">android.scaler.availableRawMinDurations</a> (static)</li>
+          <li><a href="#static_android.scaler.maxDigitalZoom">android.scaler.maxDigitalZoom</a> (static)</li>
+          <li><a href="#controls_android.sensor.frameDuration">android.sensor.frameDuration</a> (controls)</li>
+          <li><a href="#static_android.sensor.info.availableSensitivities">android.sensor.info.availableSensitivities</a> (static)</li>
+          <li><a href="#static_android.sensor.info.maxFrameDuration">android.sensor.info.maxFrameDuration</a> (static)</li>
+          <li><a href="#static_android.sensor.info.physicalSize">android.sensor.info.physicalSize</a> (static)</li>
+          <li><a href="#static_android.sensor.info.pixelArraySize">android.sensor.info.pixelArraySize</a> (static)</li>
+          <li><a href="#static_android.sensor.orientation">android.sensor.orientation</a> (static)</li>
+          <li><a href="#dynamic_android.sensor.timestamp">android.sensor.timestamp</a> (dynamic)</li>
+          <li><a href="#controls_android.statistics.faceDetectMode">android.statistics.faceDetectMode</a> (controls)</li>
+          <li><a href="#dynamic_android.statistics.faceIds">android.statistics.faceIds</a> (dynamic)</li>
+          <li><a href="#dynamic_android.statistics.faceLandmarks">android.statistics.faceLandmarks</a> (dynamic)</li>
+          <li><a href="#dynamic_android.statistics.faceRectangles">android.statistics.faceRectangles</a> (dynamic)</li>
+          <li><a href="#dynamic_android.statistics.faceScores">android.statistics.faceScores</a> (dynamic)</li>
+          <li><a href="#dynamic_android.lens.focalLength">android.lens.focalLength</a> (dynamic)</li>
+          <li><a href="#dynamic_android.lens.focusDistance">android.lens.focusDistance</a> (dynamic)</li>
+        </ul>
+      </li> <!-- tag_BC -->
+      <li id="tag_V1">V1 - 
+        New features for first camera 2 release (API1)
+    
+        <ul class="tags_entries">
+          <li><a href="#controls_android.demosaic.mode">android.demosaic.mode</a> (controls)</li>
+          <li><a href="#controls_android.flash.firingPower">android.flash.firingPower</a> (controls)</li>
+          <li><a href="#controls_android.flash.firingTime">android.flash.firingTime</a> (controls)</li>
+          <li><a href="#static_android.flash.info.chargeDuration">android.flash.info.chargeDuration</a> (static)</li>
+          <li><a href="#controls_android.hotPixel.mode">android.hotPixel.mode</a> (controls)</li>
+          <li><a href="#controls_android.lens.aperture">android.lens.aperture</a> (controls)</li>
+          <li><a href="#controls_android.lens.filterDensity">android.lens.filterDensity</a> (controls)</li>
+          <li><a href="#controls_android.lens.focalLength">android.lens.focalLength</a> (controls)</li>
+          <li><a href="#controls_android.lens.focusDistance">android.lens.focusDistance</a> (controls)</li>
+          <li><a href="#controls_android.lens.opticalStabilizationMode">android.lens.opticalStabilizationMode</a> (controls)</li>
+          <li><a href="#static_android.lens.info.availableApertures">android.lens.info.availableApertures</a> (static)</li>
+          <li><a href="#static_android.lens.info.availableFilterDensities">android.lens.info.availableFilterDensities</a> (static)</li>
+          <li><a href="#static_android.lens.info.availableFocalLengths">android.lens.info.availableFocalLengths</a> (static)</li>
+          <li><a href="#static_android.lens.info.availableOpticalStabilization">android.lens.info.availableOpticalStabilization</a> (static)</li>
+          <li><a href="#static_android.lens.info.geometricCorrectionMapSize">android.lens.info.geometricCorrectionMapSize</a> (static)</li>
+          <li><a href="#static_android.lens.info.minimumFocusDistance">android.lens.info.minimumFocusDistance</a> (static)</li>
+          <li><a href="#static_android.lens.info.shadingMapSize">android.lens.info.shadingMapSize</a> (static)</li>
+          <li><a href="#static_android.lens.position">android.lens.position</a> (static)</li>
+          <li><a href="#dynamic_android.lens.state">android.lens.state</a> (dynamic)</li>
+          <li><a href="#controls_android.noiseReduction.mode">android.noiseReduction.mode</a> (controls)</li>
+          <li><a href="#controls_android.request.id">android.request.id</a> (controls)</li>
+          <li><a href="#controls_android.sensor.exposureTime">android.sensor.exposureTime</a> (controls)</li>
+          <li><a href="#controls_android.sensor.frameDuration">android.sensor.frameDuration</a> (controls)</li>
+          <li><a href="#controls_android.sensor.sensitivity">android.sensor.sensitivity</a> (controls)</li>
+          <li><a href="#static_android.sensor.info.availableSensitivities">android.sensor.info.availableSensitivities</a> (static)</li>
+          <li><a href="#static_android.sensor.info.exposureTimeRange">android.sensor.info.exposureTimeRange</a> (static)</li>
+          <li><a href="#static_android.sensor.info.maxFrameDuration">android.sensor.info.maxFrameDuration</a> (static)</li>
+          <li><a href="#static_android.sensor.info.physicalSize">android.sensor.info.physicalSize</a> (static)</li>
+          <li><a href="#static_android.sensor.baseGainFactor">android.sensor.baseGainFactor</a> (static)</li>
+          <li><a href="#static_android.sensor.maxAnalogSensitivity">android.sensor.maxAnalogSensitivity</a> (static)</li>
+          <li><a href="#static_android.sensor.noiseModelCoefficients">android.sensor.noiseModelCoefficients</a> (static)</li>
+          <li><a href="#controls_android.statistics.histogramMode">android.statistics.histogramMode</a> (controls)</li>
+          <li><a href="#controls_android.statistics.sharpnessMapMode">android.statistics.sharpnessMapMode</a> (controls)</li>
+          <li><a href="#dynamic_android.statistics.histogram">android.statistics.histogram</a> (dynamic)</li>
+          <li><a href="#dynamic_android.statistics.sharpnessMap">android.statistics.sharpnessMap</a> (dynamic)</li>
+          <li><a href="#dynamic_android.hotPixel.mode">android.hotPixel.mode</a> (dynamic)</li>
+          <li><a href="#dynamic_android.lens.aperture">android.lens.aperture</a> (dynamic)</li>
+          <li><a href="#dynamic_android.lens.filterDensity">android.lens.filterDensity</a> (dynamic)</li>
+          <li><a href="#dynamic_android.lens.opticalStabilizationMode">android.lens.opticalStabilizationMode</a> (dynamic)</li>
+        </ul>
+      </li> <!-- tag_V1 -->
+      <li id="tag_ADV">ADV - None
+        <ul class="tags_entries">
+          <li><a href="#static_android.flash.colorTemperature">android.flash.colorTemperature</a> (static)</li>
+          <li><a href="#static_android.flash.maxEnergy">android.flash.maxEnergy</a> (static)</li>
+          <li><a href="#controls_android.geometric.strength">android.geometric.strength</a> (controls)</li>
+          <li><a href="#static_android.hotPixel.info.map">android.hotPixel.info.map</a> (static)</li>
+          <li><a href="#static_android.lens.opticalAxisAngle">android.lens.opticalAxisAngle</a> (static)</li>
+          <li><a href="#controls_android.shading.strength">android.shading.strength</a> (controls)</li>
+        </ul>
+      </li> <!-- tag_ADV -->
+      <li id="tag_DNG">DNG - 
+        Needed for DNG file support
+    
+        <ul class="tags_entries">
+          <li><a href="#static_android.lens.info.geometricCorrectionMap">android.lens.info.geometricCorrectionMap</a> (static)</li>
+          <li><a href="#static_android.lens.info.shadingMap">android.lens.info.shadingMap</a> (static)</li>
+          <li><a href="#static_android.sensor.info.activeArraySize">android.sensor.info.activeArraySize</a> (static)</li>
+          <li><a href="#static_android.sensor.info.colorFilterArrangement">android.sensor.info.colorFilterArrangement</a> (static)</li>
+          <li><a href="#static_android.sensor.info.pixelArraySize">android.sensor.info.pixelArraySize</a> (static)</li>
+          <li><a href="#static_android.sensor.info.whiteLevel">android.sensor.info.whiteLevel</a> (static)</li>
+          <li><a href="#static_android.sensor.blackLevelPattern">android.sensor.blackLevelPattern</a> (static)</li>
+          <li><a href="#static_android.sensor.calibrationTransform1">android.sensor.calibrationTransform1</a> (static)</li>
+          <li><a href="#static_android.sensor.calibrationTransform2">android.sensor.calibrationTransform2</a> (static)</li>
+          <li><a href="#static_android.sensor.colorTransform1">android.sensor.colorTransform1</a> (static)</li>
+          <li><a href="#static_android.sensor.colorTransform2">android.sensor.colorTransform2</a> (static)</li>
+          <li><a href="#static_android.sensor.forwardMatrix1">android.sensor.forwardMatrix1</a> (static)</li>
+          <li><a href="#static_android.sensor.forwardMatrix2">android.sensor.forwardMatrix2</a> (static)</li>
+          <li><a href="#static_android.sensor.referenceIlluminant1">android.sensor.referenceIlluminant1</a> (static)</li>
+          <li><a href="#controls_android.tonemap.curveRed">android.tonemap.curveRed</a> (controls)</li>
+        </ul>
+      </li> <!-- tag_DNG -->
+      <li id="tag_EXIF">EXIF - None
+        <ul class="tags_entries">
+          <li><a href="#static_android.sensor.referenceIlluminant1">android.sensor.referenceIlluminant1</a> (static)</li>
+        </ul>
+      </li> <!-- tag_EXIF -->
+    </ul>
+  </div>
+
+  [ <a href="#">top</a> ]
+
+</body>
+</html>
diff --git a/camera/docs/html.mako b/camera/docs/html.mako
index 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
new file mode 100755
index 0000000..7869763
--- /dev/null
+++ b/camera/docs/metadata-generate
@@ -0,0 +1,58 @@
+#!/bin/bash
+
+#
+# Copyright (C) 2012 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+#
+# Generate all files we have templates for:
+#   docs.html
+#   ../src/camera_metadata_tag_info.c
+#   ../src/camera_metadata_tags.h
+#
+
+thisdir=$(dirname $(readlink -f $0))
+
+function relpath() {
+    python -c "import os.path; print os.path.relpath('$1', '$PWD')"
+}
+
+function gen_file() {
+    local in=$thisdir/$1
+    local out=$thisdir/$2
+
+    python $thisdir/metadata_parser_xml.py $thisdir/metadata_properties.xml $in $out
+
+    local succ=$?
+
+    if [[ $succ -eq 0 ]]
+    then
+        echo "OK: Generated $(relpath "$out")"
+    else
+        echo "FAIL: Errors while generating $(relpath "$out")" >& 2
+    fi
+
+    return $succ
+}
+
+$thisdir/metadata-check-dependencies || exit 1
+$thisdir/metadata-parser-sanity-check || exit 1
+gen_file html.mako docs.html || exit 1
+gen_file camera_metadata_tag_info.mako ../src/camera_metadata_tag_info.c || exit 1
+gen_file camera_metadata_tags.mako ../include/system/camera_metadata_tags.h || exit 1
+
+echo "Successfully generated all metadata source files"
+
+exit 0
diff --git a/camera/docs/metadata-parser-sanity-check b/camera/docs/metadata-parser-sanity-check
index 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
new file mode 100644
index 0000000..fd09d98
--- /dev/null
+++ b/camera/docs/metadata_helpers.py
@@ -0,0 +1,243 @@
+#
+# Copyright (C) 2012 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""
+A set of helpers for rendering Mako templates with a Metadata model.
+"""
+
+import metadata_model
+from collections import OrderedDict
+
+_context_buf = None
+
+def _is_sec_or_ins(x):
+  return isinstance(x, metadata_model.Section) or    \
+         isinstance(x, metadata_model.InnerNamespace)
+
+##
+## Metadata Helpers
+##
+
+def find_all_sections(root):
+  """
+  Find all descendants that are Section or InnerNamespace instances.
+
+  Args:
+    root: a Metadata instance
+
+  Returns:
+    A list of Section/InnerNamespace instances
+
+  Remarks:
+    These are known as "sections" in the generated C code.
+  """
+  return root.find_all(_is_sec_or_ins)
+
+def find_parent_section(entry):
+  """
+  Find the closest ancestor that is either a Section or InnerNamespace.
+
+  Args:
+    entry: an Entry or Clone node
+
+  Returns:
+    An instance of Section or InnerNamespace
+  """
+  return entry.find_parent_first(_is_sec_or_ins)
+
+# find uniquely named entries (w/o recursing through inner namespaces)
+def find_unique_entries(node):
+  """
+  Find all uniquely named entries, without recursing through inner namespaces.
+
+  Args:
+    node: a Section or InnerNamespace instance
+
+  Yields:
+    A sequence of MergedEntry nodes representing an entry
+
+  Remarks:
+    This collapses multiple entries with the same fully qualified name into
+    one entry (e.g. if there are multiple entries in different kinds).
+  """
+  if not isinstance(node, metadata_model.Section) and    \
+     not isinstance(node, metadata_model.InnerNamespace):
+      raise TypeError("expected node to be a Section or InnerNamespace")
+
+  d = OrderedDict()
+  # remove the 'kinds' from the path between sec and the closest entries
+  # then search the immediate children of the search path
+  search_path = isinstance(node, metadata_model.Section) and node.kinds \
+                or [node]
+  for i in search_path:
+      for entry in i.entries:
+          d[entry.name] = entry
+
+  for k,v in d.iteritems():
+      yield v.merge()
+
+def path_name(node):
+  """
+  Calculate a period-separated string path from the root to this element,
+  by joining the names of each node and excluding the Metadata/Kind nodes
+  from the path.
+
+  Args:
+    node: a Node instance
+
+  Returns:
+    A string path
+  """
+
+  isa = lambda x,y: isinstance(x, y)
+  fltr = lambda x: not isa(x, metadata_model.Metadata) and \
+                   not isa(x, metadata_model.Kind)
+
+  path = node.find_parents(fltr)
+  path = list(path)
+  path.reverse()
+  path.append(node)
+
+  return ".".join((i.name for i in path))
+
+##
+## Filters
+##
+
+# abcDef.xyz -> ABC_DEF_XYZ
+def csym(name):
+  """
+  Convert an entry name string into an uppercase C symbol.
+
+  Returns:
+    A string
+
+  Example:
+    csym('abcDef.xyz') == 'ABC_DEF_XYZ'
+  """
+  newstr = name
+  newstr = "".join([i.isupper() and ("_" + i) or i for i in newstr]).upper()
+  newstr = newstr.replace(".", "_")
+  return newstr
+
+# abcDef.xyz -> abc_def_xyz
+def csyml(name):
+  """
+  Convert an entry name string into a lowercase C symbol.
+
+  Returns:
+    A string
+
+  Example:
+    csyml('abcDef.xyz') == 'abc_def_xyz'
+  """
+  return csym(name).lower()
+
+# pad with spaces to make string len == size. add new line if too big
+def ljust(size, indent=4):
+  """
+  Creates a function that given a string will pad it with spaces to make
+  the string length == size. Adds a new line if the string was too big.
+
+  Args:
+    size: an integer representing how much spacing should be added
+    indent: an integer representing the initial indendation level
+
+  Returns:
+    A function that takes a string and returns a string.
+
+  Example:
+    ljust(8)("hello") == 'hello   '
+
+  Remarks:
+    Deprecated. Use pad instead since it works for non-first items in a
+    Mako template.
+  """
+  def inner(what):
+    newstr = what.ljust(size)
+    if len(newstr) > size:
+      return what + "\n" + "".ljust(indent + size)
+    else:
+      return newstr
+  return inner
+
+def _find_new_line():
+
+  if _context_buf is None:
+    raise ValueError("Context buffer was not set")
+
+  buf = _context_buf
+  x = -1 # since the first read is always ''
+  cur_pos = buf.tell()
+  while buf.tell() > 0 and buf.read(1) != '\n':
+    buf.seek(cur_pos - x)
+    x = x + 1
+
+  buf.seek(cur_pos)
+
+  return int(x)
+
+# Pad the string until the buffer reaches the desired column.
+# If string is too long, insert a new line with 'col' spaces instead
+def pad(col):
+  """
+  Create a function that given a string will pad it to the specified column col.
+  If the string overflows the column, put the string on a new line and pad it.
+
+  Args:
+    col: an integer specifying the column number
+
+  Returns:
+    A function that given a string will produce a padded string.
+
+  Example:
+    pad(8)("hello") == 'hello   '
+
+  Remarks:
+    This keeps track of the line written by Mako so far, so it will always
+    align to the column number correctly.
+  """
+  def inner(what):
+    wut = int(col)
+    current_col = _find_new_line()
+
+    if len(what) > wut - current_col:
+      return what + "\n".ljust(col)
+    else:
+      return what.ljust(wut - current_col)
+  return inner
+
+# int32 -> TYPE_INT32, byte -> TYPE_BYTE, etc. note that enum -> TYPE_INT32
+def ctype_enum(what):
+  """
+  Generate a camera_metadata_type_t symbol from a type string.
+
+  Args:
+    what: a type string
+
+  Returns:
+    A string representing the camera_metadata_type_t
+
+  Example:
+    ctype_enum('int32') == 'TYPE_INT32'
+    ctype_enum('int64') == 'TYPE_INT64'
+    ctype_enum('float') == 'TYPE_FLOAT'
+
+  Remarks:
+    An enum is coerced to a byte since the rest of the camera_metadata
+    code doesn't support enums directly yet.
+  """
+  return 'TYPE_%s' %(what.upper())
diff --git a/camera/docs/metadata_model.py b/camera/docs/metadata_model.py
index 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 05953d4..7b55273 100755
--- a/camera/docs/metadata_parser_xml.py
+++ b/camera/docs/metadata_parser_xml.py
@@ -21,8 +21,8 @@
 over a Mako template.
 
 Usage:
-  metadata_parser_xml.py <filename.xml> <template.mako>
-  - outputs the resulting template to stdout
+  metadata_parser_xml.py <filename.xml> <template.mako> [<output_file>]
+  - outputs the resulting template to output_file (stdout if none specified)
 
 Module:
   The parser is also available as a module import (MetadataParserXml) to use
@@ -36,15 +36,20 @@
 """
 
 import sys
+import os
+import StringIO
 
 from bs4 import BeautifulSoup
 from bs4 import NavigableString
 
 from mako.template import Template
+from mako.lookup import TemplateLookup
+from mako.runtime import Context
 
 from metadata_model import *
 import metadata_model
 from metadata_validate import *
+import metadata_helpers
 
 class MetadataParserXml:
   """
@@ -102,34 +107,36 @@
       for tag in tags.find_all('tag'):
         self.metadata.insert_tag(tag['id'], tag.string)
 
-    for entry in self.soup.find_all("entry"):
-      d = {
-         'name': fully_qualified_name(entry),
-         'type': entry['type'],
-         'kind': find_kind(entry),
-         'type_notes': entry.attrs.get('type_notes')
-      }
+    # add all entries, preserving the ordering of the XML file
+    # this is important for future ABI compatibility when generating code
+    entry_filter = lambda x: x.name == 'entry' or x.name == 'clone'
+    for entry in self.soup.find_all(entry_filter):
+      if entry.name == 'entry':
+        d = {
+              'name': fully_qualified_name(entry),
+              'type': entry['type'],
+              'kind': find_kind(entry),
+              'type_notes': entry.attrs.get('type_notes')
+            }
 
-      d2 = self._parse_entry(entry)
+        d2 = self._parse_entry(entry)
+        insert = self.metadata.insert_entry
+      else:
+        d = {
+           'name': entry['entry'],
+           'kind': find_kind(entry),
+           'target_kind': entry['kind'],
+          # no type since its the same
+          # no type_notes since its the same
+        }
+        d2 = {}
+
+        insert = self.metadata.insert_clone
+
       d3 = self._parse_entry_optional(entry)
 
       entry_dict = dict(d.items() + d2.items() + d3.items())
-      self.metadata.insert_entry(entry_dict)
-
-    entry = None
-
-    for clone in self.soup.find_all("clone"):
-      d = {
-         'name': clone['entry'],
-         'kind': find_kind(clone),
-         'target_kind': clone['kind'],
-        # no type since its the same
-        # no type_notes since its the same
-      }
-
-      d2 = self._parse_entry_optional(clone)
-      clone_dict = dict(d.items() + d2.items())
-      self.metadata.insert_clone(clone_dict)
+      insert(entry_dict)
 
     self.metadata.construct_graph()
 
@@ -139,7 +146,7 @@
     #
     # Enum
     #
-    if entry['type'] == 'enum':
+    if entry.get('enum', 'false') == 'true':
 
       enum_values = []
       enum_optionals = []
@@ -164,6 +171,7 @@
       d['enum_optionals'] = enum_optionals
       d['enum_notes'] = enum_notes
       d['enum_ids'] = enum_ids
+      d['enum'] = True
 
     #
     # Container (Array/Tuple)
@@ -212,12 +220,29 @@
     """
     Render the metadata model using a Mako template as the view.
 
+    The template gets the metadata as an argument, as well as all
+    public attributes from the metadata_helpers module.
+
     Args:
       template: path to a Mako template file
       output_name: path to the output file, or None to use stdout
     """
-    tpl = Template(filename=template)
-    tpl_data = tpl.render(metadata=self.metadata, metadata_model=metadata_model)
+    buf = StringIO.StringIO()
+    metadata_helpers._context_buf = buf
+
+    helpers = [(i, getattr(metadata_helpers, i))
+                for i in dir(metadata_helpers) if not i.startswith('_')]
+    helpers = dict(helpers)
+
+    lookup = TemplateLookup(directories=[os.getcwd()])
+    tpl = Template(filename=template, lookup=lookup)
+
+    ctx = Context(buf, metadata=self.metadata, **helpers)
+    tpl.render_context(ctx)
+
+    tpl_data = buf.getvalue()
+    metadata_helpers._context_buf = None
+    buf.close()
 
     if output_name is None:
       print tpl_data
@@ -228,14 +253,16 @@
 #####################
 
 if __name__ == "__main__":
-  if len(sys.argv) <= 1:
-    print >> sys.stderr, "Usage: %s <filename.xml> <template.mako>"            \
-                        % (sys.argv[0])
+  if len(sys.argv) <= 2:
+    print >> sys.stderr,                                                       \
+           "Usage: %s <filename.xml> <template.mako> [<output_file>]"          \
+           % (sys.argv[0])
     sys.exit(0)
 
   file_name = sys.argv[1]
   template_name = sys.argv[2]
+  output_name = sys.argv[3] if len(sys.argv) > 3 else None
   parser = MetadataParserXml(file_name)
-  parser.render(template_name)
+  parser.render(template_name, output_name)
 
   sys.exit(0)
diff --git a/camera/docs/metadata_properties.xml b/camera/docs/metadata_properties.xml
index 127a740..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,12 +82,12 @@
     </section>
     <section name="control">
       <controls>
-        <entry name="aeAntibandingMode" type="enum">
+        <entry name="aeAntibandingMode" type="byte" enum="true">
           <enum>
-            <value>ANTIBANDING_OFF</value>
-            <value>ANTIBANDING_50HZ</value>
-            <value>ANTIBANDING_60HZ</value>
-            <value>ANTIBANDING_AUTO</value>
+            <value>OFF</value>
+            <value>50HZ</value>
+            <value>60HZ</value>
+            <value>AUTO</value>
           </enum>
           <description>Enum for controlling
           antibanding</description>
@@ -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,26 +336,26 @@
           in the frame metadata</notes>
           <tag id="BC" />
         </entry>
-        <entry name="captureIntent" type="enum">
+        <entry name="captureIntent" type="byte" enum="true">
           <enum>
-            <value>INTENT_CUSTOM
+            <value>CUSTOM
             <notes>This request doesn't fall into the other
             categories. Default to preview-like
             behavior.</notes></value>
-            <value>INTENT_PREVIEW
+            <value>PREVIEW
             <notes>This request is for a preview-like usecase. The
             precapture trigger may be used to start off a metering
             w/flash sequence</notes></value>
-            <value>INTENT_STILL_CAPTURE
+            <value>STILL_CAPTURE
             <notes>This request is for a still capture-type
             usecase.</notes></value>
-            <value>INTENT_VIDEO_RECORD
+            <value>VIDEO_RECORD
             <notes>This request is for a video recording
             usecase.</notes></value>
-            <value>INTENT_VIDEO_SNAPSHOT
+            <value>VIDEO_SNAPSHOT
             <notes>This request is for a video snapshot (still
             image while recording video) usecase</notes></value>
-            <value>INTENT_ZERO_SHUTTER_LAG
+            <value>ZERO_SHUTTER_LAG
             <notes>This request is for a ZSL usecase; the
             application will stream full-resolution images and
             reprocess one or several later for a final
@@ -368,24 +368,24 @@
           <notes>Only used if android.control.mode != OFF.</notes>
           <tag id="BC" />
         </entry>
-        <entry name="effectMode" type="enum">
+        <entry name="effectMode" type="byte" enum="true">
           <enum>
-            <value>EFFECT_OFF</value>
-            <value optional="true">EFFECT_MONO</value>
-            <value optional="true">EFFECT_NEGATIVE</value>
-            <value optional="true">EFFECT_SOLARIZE</value>
-            <value optional="true">EFFECT_SEPIA</value>
-            <value optional="true">EFFECT_POSTERIZE</value>
-            <value optional="true">EFFECT_WHITEBOARD</value>
-            <value optional="true">EFFECT_BLACKBOARD</value>
-            <value optional="true">EFFECT_AQUA</value>
+            <value>OFF</value>
+            <value optional="true">MONO</value>
+            <value optional="true">NEGATIVE</value>
+            <value optional="true">SOLARIZE</value>
+            <value optional="true">SEPIA</value>
+            <value optional="true">POSTERIZE</value>
+            <value optional="true">WHITEBOARD</value>
+            <value optional="true">BLACKBOARD</value>
+            <value optional="true">AQUA</value>
           </enum>
           <description>Whether any special color effect is in use.
           Only used if android.control.mode != OFF</description>
           <range>android.control.availableEffects</range>
           <tag id="BC" />
         </entry>
-        <entry name="mode" type="enum">
+        <entry name="mode" type="byte" enum="true">
           <enum>
             <value>OFF
             <notes>Full application control of pipeline. All 3A
@@ -410,9 +410,10 @@
           <range>all must be supported</range>
           <tag id="BC" />
         </entry>
-        <entry name="sceneMode" type="enum">
+        <entry name="sceneMode" type="byte" enum="true">
           <enum>
-            <value>SCENE_MODE_FACE_PRIORITY
+            <value id="0">UNSUPPORTED</value>
+            <value>FACE_PRIORITY
             <notes>if face detection support exists Use face
             detection data to drive 3A routines. If face detection
             statistics are disabled, should still operate correctly
@@ -421,29 +422,28 @@
             awbMode, and afMode remain active when FACE_PRIORITY is
             set. This is due to compatibility concerns with the old
             camera API</notes></value>
-            <value optional="true">SCENE_MODE_ACTION</value>
-            <value optional="true">SCENE_MODE_PORTRAIT</value>
-            <value optional="true">SCENE_MODE_LANDSCAPE</value>
-            <value optional="true">SCENE_MODE_NIGHT</value>
-            <value optional="true">
-            SCENE_MODE_NIGHT_PORTRAIT</value>
-            <value optional="true">SCENE_MODE_THEATRE</value>
-            <value optional="true">SCENE_MODE_BEACH</value>
-            <value optional="true">SCENE_MODE_SNOW</value>
-            <value optional="true">SCENE_MODE_SUNSET</value>
-            <value optional="true">SCENE_MODE_STEADYPHOTO</value>
-            <value optional="true">SCENE_MODE_FIREWORKS</value>
-            <value optional="true">SCENE_MODE_SPORTS</value>
-            <value optional="true">SCENE_MODE_PARTY</value>
-            <value optional="true">SCENE_MODE_CANDLELIGHT</value>
-            <value optional="true">SCENE_MODE_BARCODE</value>
+            <value optional="true">ACTION</value>
+            <value optional="true">PORTRAIT</value>
+            <value optional="true">LANDSCAPE</value>
+            <value optional="true">NIGHT</value>
+            <value optional="true">NIGHT_PORTRAIT</value>
+            <value optional="true">THEATRE</value>
+            <value optional="true">BEACH</value>
+            <value optional="true">SNOW</value>
+            <value optional="true">SUNSET</value>
+            <value optional="true">STEADYPHOTO</value>
+            <value optional="true">FIREWORKS</value>
+            <value optional="true">SPORTS</value>
+            <value optional="true">PARTY</value>
+            <value optional="true">CANDLELIGHT</value>
+            <value optional="true">BARCODE</value>
           </enum>
           <description>Which scene mode is active when
           android.control.mode = SCENE_MODE</description>
           <range>android.control.availableSceneModes</range>
           <tag id="BC" />
         </entry>
-        <entry name="videoStabilizationMode" type="enum">
+        <entry name="videoStabilizationMode" type="byte" enum="true">
           <enum>
             <value>OFF</value>
             <value>ON</value>
@@ -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
@@ -652,11 +652,11 @@
             <notes>if AUTO or MACRO modes are supported AF is doing
             an AF scan because it was triggered by AF
             trigger</notes></value>
-            <value>AF_FOCUSED_LOCKED
+            <value>FOCUSED_LOCKED
             <notes>if any AF mode besides OFF is supported AF
             believes it is focused correctly and is
             locked</notes></value>
-            <value>AF_NOT_FOCUSED_LOCKED
+            <value>NOT_FOCUSED_LOCKED
             <notes>if any AF mode besides OFF is supported AF has
             failed to focus successfully and is
             locked</notes></value>
@@ -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,10 +1192,10 @@
             <tag id="V1" />
           </entry>
         </namespace>
-        <entry name="facing" type="enum">
+        <entry name="facing" type="byte" enum="true">
           <enum>
-            <value>FACING_FRONT</value>
-            <value>FACING_BACK</value>
+            <value>FRONT</value>
+            <value>BACK</value>
           </enum>
           <description>Direction the camera faces relative to
           device screen</description>
@@ -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>
@@ -1522,6 +1522,9 @@
           include: - half/quarter max resolution</range>
           <tag id="BC" />
         </entry>
+        <entry name="availableMaxDigitalZoom" type="int32">
+          <description>TODO: have a real description here</description>
+        </entry>
         <entry name="availableProcessedMinDurations" type="int64"
         container="array">
           <array>
@@ -1649,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>
@@ -1841,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>
@@ -1901,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>
@@ -1930,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
@@ -1946,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>
@@ -1955,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>
@@ -2089,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>
@@ -2120,7 +2123,7 @@
           0.25, 0.3 -&gt; 0.5, 0.5 -&gt; 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
     };
 
     /*