CPCam: Add CPCamMetadata

Added new class CPCamMetadata.
Removed obsolete class CPCamUtils.

Change-Id: I69b652ae827ffc583c69a678d8efce96ed9e75ce
Signed-off-by: Emilian Peev <epeev@mm-sol.com>
Signed-off-by: Vladimir Petrov <vppetrov@mm-sol.com>

5 files changed, 1069 insertions, 28 deletions

diff --git a/cpcam/java/com/ti/omap/android/cpcam/CPCamMetadata.java b/cpcam/java/com/ti/omap/android/cpcam/CPCamMetadata.java
new file mode 100644
index 0000000..e1945e2
--- /dev/null
+++ b/cpcam/java/com/ti/omap/android/cpcam/CPCamMetadata.java
@@ -0,0 +1,449 @@
+/*
+ * Copyright (C) 2010 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.
+ */
+
+package com.ti.omap.android.cpcam;
+
+import android.graphics.*;
+import java.nio.ByteBuffer;
+
+/**
+ * Used for passing camera related metadata
+ */
+public class CPCamMetadata {
+
+    protected CPCamMetadata() {
+    }
+
+    public static CPCamMetadata getMetadata(SurfaceTexture st) {
+        return nativeRetrieveMetadata(st);
+    }
+
+    public static class BSCPosition {
+
+        /**
+         * The number of row/column sums cannot exceed 1920, implies:
+         *  -  (vectors + 1) * (vertical_number) <=1920, for row sums
+         *  -  (vectors + 1) * (horizontal_number) <=1920, for column sums
+         */
+        BSCPosition () {
+        }
+
+        /**
+         * vectors : number of row/column sum vectors. Max value = 4
+         */
+        public int vectors;
+
+        /**
+         * shift : down-shift of input data
+         */
+        public int shift;
+
+        /**
+         * vertical_position : vertical position of first pixel to be summed
+         */
+        public int verticalPosition;
+
+        /**
+         * horizontal_position : horizontal position of first pixel to be summed
+         */
+        public int horizontalPosition;
+
+        /**
+         * vertical_number : number of pixels sampled vertically
+         */
+        public int verticalNumber;
+
+        /**
+         * horizontal_number : number of pixels sampled horizontally
+         */
+        public int horizontalNumber;
+
+        /**
+         * vertical_skip : vertical spacing between adjacent pixels to be summed
+         */
+        public int verticalSkip;
+
+        /**
+         * horizontal_skip : horizontal pixel spacing between adjacent pixels to be summed
+         */
+        public int horizontalSkip;
+    }
+
+    public static class H3AConfig {
+
+        H3AConfig () {
+        }
+
+        /**
+         * vertical_position: vertical start point of paxel grid
+         * w.r.t first pixel of input image frame
+         */
+        public int verticalPosition;
+
+        /**
+         * vertical_size: vertical paxel size
+         */
+        public int verticalSize;
+
+        /**
+         * horizontal_position: horizontal start point of paxel grid
+         * w.r.t first pixel of input image frame
+         */
+        public int horizontalPosition;
+
+        /**
+         * horizontal_size: horizontal paxel size
+         */
+        public int horizontalSize;
+
+        /**
+         * vertical_count: num of vert paxels. AF/AEWB paxels
+         * are always adjacent to each other
+         */
+        public int verticalCount;
+
+        /**
+         * vetical_increment: num of pixels to skip within a paxel, vertically
+         */
+        public int veticalIncrement;
+
+        /**
+         * horizontal_count: num of horz paxels.
+         * AF/AEWB paxels are always adjacent to each other
+         */
+        public int horizontalCount;
+
+        /**
+         * horizontal_increment: num of pixels to skip within a paxel,
+         * horizontally
+         */
+        public int horizontalIncrement;
+    }
+
+    /**
+     * Used to store the information about frame
+     * number in processing sequence (i.e preview)
+     */
+    public int frameNumber;
+
+    /**
+     * Used to store the information about shot number
+     * in a burst sequence.
+     */
+    public int shotNumber;
+
+    /**
+     * Used to store analog gain information for
+     * current frame. Metadata is represented as 100*EV.
+     */
+    public int analogGain;
+
+    /**
+     * Used for storing analog gain information
+     * requested by application for current frame. Metadata is represented as 100*EV.
+     */
+    public int analogGainReq;
+
+    /**
+     * Used for storing the analog gain
+     * lower limit for current frame. Metadata is represented as 100*EV.
+     */
+    public int analogGainMin;
+
+    /**
+     * Used for storing the analog gain
+     * upper limit for current frame. Metadata is represented as 100*EV.
+     */
+    public int analogGainMax;
+
+    /**
+     * Used for storing the analog gain
+     * deviation after flicker reduction for current frame. Metadata is represented as 100*EV.
+     */
+    public int analogGainDev;
+
+    /**
+     * Used for storing analog gain error for
+     * current frame. Represents the difference between requested value and actual value.
+     */
+    public int analogGainError;
+
+    /**
+     * Used for storing the exposure time for current frame.
+     * Metadata is represented in us.
+     */
+    public int exposureTime;
+
+    /**
+     * Used for storing the exposure time requested by
+     * application for current frame. Metadata is represented in us.
+     */
+    public int exposureTimeReq;
+
+    /**
+     * Used for storing the exposure time lower limit for
+     * current frame. Metadata is represented in us.
+     */
+    public int exposureTimeMin;
+
+    /**
+     * Used for storing the exposure time upper limit for
+     * current frame. Metadata is represented in us.
+     */
+    public int exposureTimeMax;
+
+    /**
+     * Used for storing the exposure time
+     * deviation after flicker reduction for current frame. Metadata is represented in us.
+     */
+    public int exposureTimeDev;
+
+    /**
+     * Used for storing the time difference between
+     * requested exposure time and actual exposure time.
+     */
+    public int exposureTimeError;
+
+    /**
+     * Used for storing the current total exposure
+     * compensation requested by application for current frame.  Metadata is represented as 100*EV.
+     */
+    public int exposureCompensationReq;
+
+    /**
+     * Used for storing current total exposure
+     * deviation for current frame.  Metadata is represented as 100*EV.
+     */
+    public int exposureDev;
+
+    /**
+     * Represents the timestamp in terms of a reference clock.
+     */
+    public long timestamp;
+
+    /**
+     * Represents the temperature of current scene in Kelvin
+     */
+    public int awbTemp;
+
+    /**
+     * Represent gains applied to each RGGB color channel.
+     */
+    public int gainR;
+    public int gainGR;
+    public int gainGB;
+    public int gainB;
+
+    /**
+     * Represent offsets applied to each RGGB color channel.
+     */
+    public int offsetR;
+    public int offsetGR;
+    public int offsetGB;
+    public int offsetB;
+
+    /**
+     * Used to store the current
+     * lens shading correction table.  The table consists of an
+     * N by M array of elements.  Each element has 4 integer values
+     * ranging from 0 to 1000, corresponding to a multiplier for
+     * each of the Bayer color filter channels (R, Gr, Gb, B).
+     * Correction is performed on pixels in a Bayer image by interpolating
+     * the corresponding color filter channel in the array, and then
+     * multiplying by (value/1000).
+     */
+    public ByteBuffer lscTable;
+
+    /**
+     * Indicates whether LSC table is applied or not
+     */
+    public int lscTableApplied;
+
+    /**
+     * An array of the detected faces. The length is numberOfFaces.
+     * The Face rectangles have to following layout:
+     * int top - Top coordinate of the face rectangle,
+     * int left - Left coordinate of the face rectangle,
+     * int bottom - Bottom coordinate of the face rectangle.
+     * int right - Right coordnate of the face rectangle.
+     */
+    public ByteBuffer faces;
+
+    public int numberOfFaces;
+
+    /**
+     * Width of the auxiliary image
+     */
+    public int auxImageWidth;
+
+    /**
+     * Height of the auxiliary image
+     */
+    public int auxImageHeight;
+
+    /**
+     * Auxiliary image buffer NV12 pixelformat
+     */
+    public ByteBuffer auxImage;
+
+    /**
+     * Element to be summed
+     *   Y = 0,
+     *   Cb = 1,
+     *   Cr = 2,
+    */
+    public int bscColorElement;
+
+    /**
+     *  BSC row sum descriptor
+     */
+    BSCPosition bscRowPosition;
+
+    /**
+     * BSC column sum descriptor
+     */
+    BSCPosition bscColPosition;
+
+    /**
+     * Each value corresponds to sum value in a row.
+     * Num of row sums = row_position.vectors * row_position.vertical_number
+     */
+    public ByteBuffer bscRowSum;
+
+    /**
+     * Each value corresponds to sum value in a row.
+     * Num of row sums = row_position.vectors * row_position.vertical_number
+     */
+    public ByteBuffer bscColSum;
+
+    /**
+     * When Vertical focus is disabled, R,G,B location w.r.t.
+     * to paxel start location is specified by this field.
+     *      AF_RGBPOSITION_BAYER_GR_GB = 0
+     *      AF_RGBPOSITION_BAYER_RG_GB = 1
+     *      AF_RGBPOSITION_BAYER_GR_BG = 2
+     *      AF_RGBPOSITION_BAYER_RG_BG = 3
+     *      AF_RGBPOSITION_CUSTOM_GG_RB = 4
+     *      AF_RGBPOSITION_CUSTOM_RB_GG = 5
+     */
+    public int afBayeRGBPosition;
+
+    /**
+     * If enabled, peak for FV, FV^2 is computed for a paxel.
+     * If disabled, average of FV, FV^2 is computed for a paxel.
+     */
+    public int afEnableAFPeakMode;
+
+    /**
+     * Whether vertical focus is enabled.
+     */
+    public int afEnableAFVertical;
+
+    /**
+     * AF paxel description
+     */
+    public H3AConfig afPaxelWindow;
+
+    /**
+     * Output AF buffer. Data is ordered in paxels:
+     *
+     * g_paxel - Paxel information for green color
+     * rb_paxel - Paxel information for red/blue color
+     * br_paxel - Paxel information for blue/red color
+     *
+     * Each paxel consists of :
+     *     int sum - Sum of the pixels used to arrive at
+     *               the statistics for a paxel
+     *     int focus_value_sum - Focus Value (sum/peak)
+     *                           for a paxel
+     *     int focus_value_sqr_sum - Focus Value Squared
+     *                               (sum/peak) for a paxel
+     *     int reserved - To be ignored
+     *   ------------------------------------
+     *  | G paxel                            |
+     *  | ------   ------   ------   ------  |
+     *  ||      | |      | |      | |      | |
+     *  || sum  | |f_sum | |f_sum | | rsv  | |
+     *  ||      | |      | |sqr   | |      | |
+     *  | ------   ------   ------   ------  |
+     *   ------------------------------------
+     *
+     *   ------------------------------------
+     *  | RB paxel                           |
+     *  | ------   ------   ------   ------  |
+     *  ||      | |      | |      | |      | |
+     *  || sum  | |f_sum | |f_sum | | rsv  | |
+     *  ||      | |      | |sqr   | |      | |
+     *  | ------   ------   ------   ------  |
+     *   ------------------------------------
+     *
+     *   ------------------------------------
+     *  | BR paxel                           |
+     *  | ------   ------   ------   ------  |
+     *  ||      | |      | |      | |      | |
+     *  || sum  | |f_sum | |f_sum | | rsv  | |
+     *  ||      | |      | |sqr   | |      | |
+     *  | ------   ------   ------   ------  |
+     *   ------------------------------------
+     */
+    public ByteBuffer afPaxelStatistics;
+
+    /**
+     * AEWB mode :
+     * AEWB_MODE_SUM_OF_SQUARE = 0 - Sum of square calculated
+     *                               across sub-samples in a paxel.
+     * AEWB_MODE_MINMAX = 1 - Min-max calculted across sub-samples
+     *                        in a paxel.
+     * AEWB_MODE_SUM_ONLY = 2 - Only Sum calculated across sub-samples
+     *                           in a paxel.
+     */
+    public int aewbMode;
+
+    /**
+     * Threshold against which pixel values are compared
+     */
+    public int aewbThresholdPixelValue;
+
+    /**
+     * Right shift value applied on result of pixel accumulation
+     */
+    public int aewbAccumulationShift;
+
+    /**
+     * AE/AWB paxel description
+     */
+    public H3AConfig aewbPaxelWindow;
+
+    /**
+     * Output AE/AWB buffer, containing:
+     * subsampled_acc_values[4] - Sub sample accumulator(s), not-clipped.
+     *                            Separate for each pixel in 2x2 sub-sample.
+     * saturator_acc_values[4] - Saturator accumulator(s), clipped based upon threshold.
+     *                           Separate for each pixel in 2x2 sub-sample.
+     * nUnsaturatedCount[2] - Count of unsaturated 2x2 sub-samples in a paxel.
+     *                        (LS 16-bits stored in [0], MS stored in [1])
+     */
+    public ByteBuffer aewbPaxelStatistics;
+
+    private static native CPCamMetadata nativeRetrieveMetadata(SurfaceTexture st);
+
+    /*
+     * We use a class initializer to allow the native code to cache some
+     * field offsets.
+     */
+    private static native void nativeClassInit();
+    static { nativeClassInit(); }
+}
diff --git a/cpcam/java/com/ti/omap/android/cpcam/CPCamUtils.java b/cpcam/java/com/ti/omap/android/cpcam/CPCamUtils.java
deleted file mode 100644
index f7e5023..0000000
--- a/cpcam/java/com/ti/omap/android/cpcam/CPCamUtils.java
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * Copyright (C) 2008 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.
- */
-
-package com.ti.omap.android.cpcam;
-
-import android.graphics.SurfaceTexture;
-
-public class CPCamUtils {
-
-    public static String getMetadata(SurfaceTexture st) {
-        return st.getMetadata();
-    }
-
-}
diff --git a/cpcam/jni/Android.mk b/cpcam/jni/Android.mk
index d0a9b99..3ca6e01 100644
--- a/cpcam/jni/Android.mk
+++ b/cpcam/jni/Android.mk
@@ -42,7 +42,8 @@ LOCAL_MODULE:= libcpcam_jni
 
 # All of the source files that we will compile.
 LOCAL_SRC_FILES:= \
-	com_ti_omap_android_cpcam_CPCam.cpp
+	com_ti_omap_android_cpcam_CPCam.cpp \
+	com_ti_omap_android_cpcam_CPCamMetadata.cpp
 
 # All of the shared libraries we link against.
 LOCAL_SHARED_LIBRARIES := \
@@ -52,6 +53,7 @@ LOCAL_SHARED_LIBRARIES := \
 	libcutils \
 	libutils \
 	libui \
+	libbinder \
 	libgui
 
 # No static libraries.
diff --git a/cpcam/jni/com_ti_omap_android_cpcam_CPCam.cpp b/cpcam/jni/com_ti_omap_android_cpcam_CPCam.cpp
index d3a2f71..240e55e 100644
--- a/cpcam/jni/com_ti_omap_android_cpcam_CPCam.cpp
+++ b/cpcam/jni/com_ti_omap_android_cpcam_CPCam.cpp
@@ -59,6 +59,8 @@
 
 using namespace android;
 
+extern int register_com_ti_omap_android_cpcam_CPCamMetadata(JNIEnv* env);
+
 struct fields_t {
     jfieldID    context;
     jfieldID    surface;
@@ -1142,6 +1144,11 @@ jint JNI_OnLoad(JavaVM* vm, void* reserved) {
         goto bail;
     }
 
+    if ( register_com_ti_omap_android_cpcam_CPCamMetadata(env) != 0 ) {
+        LOGE("ERROR: PlatformLibrary native Metadata registration failed\n");
+        goto bail;
+    }
+
     /* success -- return valid version number */
     result = JNI_VERSION_1_4;
 
diff --git a/cpcam/jni/com_ti_omap_android_cpcam_CPCamMetadata.cpp b/cpcam/jni/com_ti_omap_android_cpcam_CPCamMetadata.cpp
new file mode 100644
index 0000000..fac2df8
--- /dev/null
+++ b/cpcam/jni/com_ti_omap_android_cpcam_CPCamMetadata.cpp
@@ -0,0 +1,610 @@
+/*
+**
+** Copyright 2008, 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 "jni.h"
+#include "JNIHelp.h"
+#include "android_runtime/AndroidRuntime.h"
+
+#include <gui/SurfaceTexture.h>
+
+#include <binder/IMemory.h>
+#include <binder/MemoryBase.h>
+#include <binder/MemoryHeapBase.h>
+
+using namespace android;
+
+const char* const kMetadataClassPathName = "com/ti/omap/android/cpcam/CPCamMetadata";
+
+struct fields_t {
+    jmethodID metadataInit;
+    jmethodID rectInit;
+    jmethodID bscPositionInit;
+    jmethodID h3aInit;
+    jfieldID frameNumber;
+    jfieldID shotNumber;
+    jfieldID analogGain;
+    jfieldID analogGainReq;
+    jfieldID analogGainMin;
+    jfieldID analogGainMax;
+    jfieldID analogGainDev;
+    jfieldID analogGainError;
+    jfieldID exposureTime;
+    jfieldID exposureTimeReq;
+    jfieldID exposureTimeMin;
+    jfieldID exposureTimeMax;
+    jfieldID exposureTimeDev;
+    jfieldID exposureTimeError;
+    jfieldID exposureCompensationReq;
+    jfieldID exposureDev;
+    jfieldID timestamp;
+    jfieldID awbTemp;
+    jfieldID gainR;
+    jfieldID gainGR;
+    jfieldID gainGB;
+    jfieldID gainB;
+    jfieldID offsetR;
+    jfieldID offsetGR;
+    jfieldID offsetGB;
+    jfieldID offsetB;
+    jfieldID lscTableApplied;
+    jfieldID faces;
+    jfieldID numberOfFaces;
+    jfieldID auxImageWidth;
+    jfieldID auxImageHeight;
+    jfieldID bscColorElement;
+    jfieldID bscRowPosition;
+    jfieldID bscColPosition;
+    jfieldID afBayeRGBPosition;
+    jfieldID afEnableAFPeakMode;
+    jfieldID afEnableAFVertical;
+    jfieldID afPaxelWindow;
+    jfieldID aewbMode;
+    jfieldID aewbThresholdPixelValue;
+    jfieldID aewbPaxelWindow;
+    jfieldID aewbAccumulationShift;
+    jfieldID lscTable;
+    jfieldID auxImage;
+    jfieldID bscRowSum;
+    jfieldID bscColSum;
+    jfieldID afPaxelStatistics;
+    jfieldID aewbPaxelStatistics;
+    jfieldID bscPositionVectors;
+    jfieldID bscPositionShift;
+    jfieldID bscPositionVerticalPosition;
+    jfieldID bscPositionHorizontalPosition;
+    jfieldID bscPositionVerticalNumber;
+    jfieldID bscPositionHorizontalNumber;
+    jfieldID bscPositionVerticalSkip;
+    jfieldID bscPositionHorizontalSkip;
+    jfieldID h3aVerticalPosition;
+    jfieldID h3aVerticalSize;
+    jfieldID h3aHorizontalPosition;
+    jfieldID h3aHorizontalSize;
+    jfieldID h3aVerticalCount;
+    jfieldID h3aVeticalIncrement;
+    jfieldID h3aHorizontalCount;
+    jfieldID h3aHorizontalIncrement;
+
+};
+
+static fields_t fields;
+
+static void Metadata_Init(JNIEnv* env, jclass clazz)
+{
+
+    jclass metaDataClazz = env->FindClass("com/ti/omap/android/cpcam/CPCamMetadata");
+    if ( NULL == metaDataClazz ) {
+        LOGE("Couldn't find CPCamMetadata class");
+    }
+
+    fields.metadataInit = env->GetMethodID(metaDataClazz, "<init>", "()V");
+    if ( NULL == fields.metadataInit ) {
+        LOGE("Couldn't find Metadata constructor");
+    }
+
+    jclass rectClazz = env->FindClass("android/graphics/Rect");
+    if ( NULL == rectClazz ) {
+        LOGE("Couldn't find Rect class");
+    }
+
+    fields.rectInit = env->GetMethodID(rectClazz, "<init>", "(IIII)V");
+    if ( NULL == fields.rectInit ) {
+        LOGE("Couldn't find Rect constructor");
+    }
+
+    fields.frameNumber = env->GetFieldID(metaDataClazz, "frameNumber", "I");
+    if ( NULL == fields.frameNumber ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.shotNumber = env->GetFieldID(metaDataClazz, "shotNumber", "I");
+    if ( NULL == fields.shotNumber ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.analogGain = env->GetFieldID(metaDataClazz, "analogGain", "I");
+    if ( NULL == fields.analogGain ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.analogGainReq = env->GetFieldID(metaDataClazz, "analogGainReq", "I");
+    if ( NULL == fields.analogGainReq ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.analogGainMin = env->GetFieldID(metaDataClazz, "analogGainMin", "I");
+    if ( NULL == fields.analogGainMin ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.analogGainMax = env->GetFieldID(metaDataClazz, "analogGainMax", "I");
+    if ( NULL == fields.analogGainMax ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.analogGainDev = env->GetFieldID(metaDataClazz, "analogGainDev", "I");
+    if ( NULL == fields.analogGainDev ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.analogGainError = env->GetFieldID(metaDataClazz, "analogGainError", "I");
+    if ( NULL == fields.analogGainError ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.exposureTime = env->GetFieldID(metaDataClazz, "exposureTime", "I");
+    if ( NULL == fields.exposureTime ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.exposureTimeReq = env->GetFieldID(metaDataClazz, "exposureTimeReq", "I");
+    if ( NULL == fields.exposureTimeReq ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.exposureTimeMin = env->GetFieldID(metaDataClazz, "exposureTimeMin", "I");
+    if ( NULL == fields.exposureTimeMin ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.exposureTimeMax = env->GetFieldID(metaDataClazz, "exposureTimeMax", "I");
+    if ( NULL == fields.exposureTimeMax ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.exposureTimeDev = env->GetFieldID(metaDataClazz, "exposureTimeDev", "I");
+    if ( NULL == fields.exposureTimeDev ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.exposureTimeError = env->GetFieldID(metaDataClazz, "exposureTimeError", "I");
+    if ( NULL == fields.exposureTimeError ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.exposureCompensationReq = env->GetFieldID(metaDataClazz, "exposureCompensationReq", "I");
+    if ( NULL == fields.exposureCompensationReq ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.exposureDev = env->GetFieldID(metaDataClazz, "exposureDev", "I");
+    if ( NULL == fields.exposureDev ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.timestamp = env->GetFieldID(metaDataClazz, "timestamp", "J");
+    if ( NULL == fields.timestamp ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.awbTemp = env->GetFieldID(metaDataClazz, "awbTemp", "I");
+    if ( NULL == fields.awbTemp ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.gainR = env->GetFieldID(metaDataClazz, "gainR", "I");
+    if ( NULL == fields.gainR ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.gainGR = env->GetFieldID(metaDataClazz, "gainGR", "I");
+    if ( NULL == fields.gainGR ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.gainGB = env->GetFieldID(metaDataClazz, "gainGB", "I");
+    if ( NULL == fields.gainGB ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.gainB = env->GetFieldID(metaDataClazz, "gainB", "I");
+    if ( NULL == fields.gainB ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.offsetR = env->GetFieldID(metaDataClazz, "offsetR", "I");
+    if ( NULL == fields.offsetR ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.offsetGR = env->GetFieldID(metaDataClazz, "offsetGR", "I");
+    if ( NULL == fields.offsetGR ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.offsetGB = env->GetFieldID(metaDataClazz, "offsetGB", "I");
+    if ( NULL == fields.offsetGB ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.offsetB = env->GetFieldID(metaDataClazz, "offsetB", "I");
+    if ( NULL == fields.offsetB ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.lscTableApplied = env->GetFieldID(metaDataClazz, "lscTableApplied", "I");
+    if ( NULL == fields.lscTableApplied ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.faces = env->GetFieldID(metaDataClazz, "faces", "Ljava/nio/ByteBuffer;");
+    if ( NULL == fields.faces ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.numberOfFaces = env->GetFieldID(metaDataClazz, "numberOfFaces", "I");
+    if ( NULL == fields.numberOfFaces ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.auxImageWidth = env->GetFieldID(metaDataClazz, "auxImageWidth", "I");
+    if ( NULL == fields.auxImageWidth ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.auxImageHeight = env->GetFieldID(metaDataClazz, "auxImageHeight", "I");
+    if ( NULL == fields.auxImageHeight ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.bscColorElement = env->GetFieldID(metaDataClazz, "bscColorElement", "I");
+    if ( NULL == fields.bscColorElement ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    jclass bscPositionClazz = env->FindClass("com/ti/omap/android/cpcam/CPCamMetadata$BSCPosition");
+    if ( NULL == bscPositionClazz ) {
+        LOGE("Couldn't find BSCPosition class");
+    }
+
+    fields.bscPositionInit = env->GetMethodID(bscPositionClazz, "<init>", "()V");
+    if ( NULL == fields.bscPositionInit ) {
+        LOGE("Couldn't find BSCPosition constructor");
+    }
+
+    fields.bscPositionVectors = env->GetFieldID(bscPositionClazz, "vectors", "I");
+    if ( NULL == fields.bscPositionVectors ) {
+        LOGE("Couldn't allocate BSCPosition field");
+    }
+
+    fields.bscPositionShift = env->GetFieldID(bscPositionClazz, "shift", "I");
+    if ( NULL == fields.bscPositionShift ) {
+        LOGE("Couldn't allocate BSCPosition field");
+    }
+
+    fields.bscPositionVerticalPosition = env->GetFieldID(bscPositionClazz,
+                                                         "verticalPosition",
+                                                         "I");
+    if ( NULL == fields.bscPositionVerticalPosition ) {
+        LOGE("Couldn't allocate BSCPosition field");
+    }
+
+    fields.bscPositionHorizontalPosition = env->GetFieldID(bscPositionClazz,
+                                                           "horizontalPosition",
+                                                           "I");
+    if ( NULL == fields.bscPositionHorizontalPosition ) {
+        LOGE("Couldn't allocate BSCPosition field");
+    }
+
+    fields.bscPositionVerticalNumber = env->GetFieldID(bscPositionClazz,
+                                                       "verticalNumber",
+                                                       "I");
+    if ( NULL == fields.bscPositionVerticalNumber ) {
+        LOGE("Couldn't allocate BSCPosition field");
+    }
+
+    fields.bscPositionHorizontalNumber = env->GetFieldID(bscPositionClazz,
+                                                         "horizontalNumber",
+                                                         "I");
+    if ( NULL == fields.bscPositionHorizontalNumber ) {
+        LOGE("Couldn't allocate BSCPosition field");
+    }
+
+    fields.bscPositionVerticalSkip = env->GetFieldID(bscPositionClazz,
+                                                     "verticalSkip",
+                                                     "I");
+    if ( NULL == fields.bscPositionVerticalSkip ) {
+        LOGE("Couldn't allocate BSCPosition field");
+    }
+
+    fields.bscPositionHorizontalSkip = env->GetFieldID(bscPositionClazz,
+                                                       "horizontalSkip",
+                                                       "I");
+    if ( NULL == fields.bscPositionHorizontalSkip ) {
+        LOGE("Couldn't allocate BSCPosition field");
+    }
+
+    fields.bscRowPosition = env->GetFieldID(metaDataClazz,
+                                            "bscRowPosition",
+                                            "Lcom/ti/omap/android/cpcam/CPCamMetadata$BSCPosition;");
+    if ( NULL == fields.bscRowPosition ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.bscColPosition = env->GetFieldID(metaDataClazz,
+                                            "bscColPosition",
+                                            "Lcom/ti/omap/android/cpcam/CPCamMetadata$BSCPosition;");
+    if ( NULL == fields.bscColPosition ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.afBayeRGBPosition = env->GetFieldID(metaDataClazz, "afBayeRGBPosition", "I");
+    if ( NULL == fields.afBayeRGBPosition ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.afEnableAFPeakMode = env->GetFieldID(metaDataClazz, "afEnableAFPeakMode", "I");
+    if ( NULL == fields.afEnableAFPeakMode ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.afEnableAFVertical = env->GetFieldID(metaDataClazz, "afEnableAFVertical", "I");
+    if ( NULL == fields.afEnableAFVertical ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.afPaxelWindow = env->GetFieldID(metaDataClazz,
+                                                "afPaxelWindow",
+                                                "Lcom/ti/omap/android/cpcam/CPCamMetadata$H3AConfig;");
+    if ( NULL == fields.afPaxelWindow ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    jclass h3aConfigClazz = env->FindClass("com/ti/omap/android/cpcam/CPCamMetadata$H3AConfig");
+    if ( NULL == h3aConfigClazz ) {
+        LOGE("Couldn't find H3AConfig class");
+    }
+
+    fields.h3aVerticalPosition = env->GetFieldID(h3aConfigClazz, "verticalPosition", "I");
+    if ( NULL == fields.h3aVerticalPosition ) {
+        LOGE("Couldn't allocate H3AConfig field");
+    }
+
+    fields.h3aVerticalSize = env->GetFieldID(h3aConfigClazz, "verticalSize", "I");
+    if ( NULL == fields.h3aVerticalSize ) {
+        LOGE("Couldn't allocate H3AConfig field");
+    }
+
+    fields.h3aHorizontalPosition = env->GetFieldID(h3aConfigClazz, "horizontalPosition", "I");
+    if ( NULL == fields.h3aHorizontalPosition ) {
+        LOGE("Couldn't allocate H3AConfig field");
+    }
+
+    fields.h3aHorizontalSize = env->GetFieldID(h3aConfigClazz, "horizontalSize", "I");
+    if ( NULL == fields.h3aHorizontalSize ) {
+        LOGE("Couldn't allocate H3AConfig field");
+    }
+
+    fields.h3aVerticalCount = env->GetFieldID(h3aConfigClazz, "verticalCount", "I");
+    if ( NULL == fields.h3aVerticalCount ) {
+        LOGE("Couldn't allocate H3AConfig field");
+    }
+
+    fields.h3aVeticalIncrement = env->GetFieldID(h3aConfigClazz, "veticalIncrement", "I");
+    if ( NULL == fields.h3aVeticalIncrement ) {
+        LOGE("Couldn't allocate H3AConfig field");
+    }
+
+    fields.h3aHorizontalCount = env->GetFieldID(h3aConfigClazz, "horizontalCount", "I");
+    if ( NULL == fields.h3aHorizontalCount ) {
+        LOGE("Couldn't allocate H3AConfig field");
+    }
+
+    fields.h3aHorizontalIncrement = env->GetFieldID(h3aConfigClazz, "horizontalIncrement", "I");
+    if ( NULL == fields.h3aHorizontalIncrement ) {
+        LOGE("Couldn't allocate H3AConfig field");
+    }
+
+    fields.h3aInit = env->GetMethodID(h3aConfigClazz, "<init>", "()V");
+    if ( NULL == fields.h3aInit ) {
+        LOGE("Couldn't find H3AConfig constructor");
+    }
+
+    fields.aewbMode = env->GetFieldID(metaDataClazz, "aewbMode", "I");
+    if ( NULL == fields.aewbMode ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.aewbThresholdPixelValue = env->GetFieldID(metaDataClazz, "aewbThresholdPixelValue", "I");
+    if ( NULL == fields.aewbThresholdPixelValue ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.aewbAccumulationShift = env->GetFieldID(metaDataClazz, "aewbAccumulationShift", "I");
+    if ( NULL == fields.aewbAccumulationShift ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.aewbPaxelWindow = env->GetFieldID(metaDataClazz,
+                                             "aewbPaxelWindow",
+                                             "Lcom/ti/omap/android/cpcam/CPCamMetadata$H3AConfig;");
+    if ( NULL == fields.aewbPaxelWindow ) {
+        LOGE("Couldn't allocate Metadata field");
+    }
+
+    fields.lscTable = env->GetFieldID(metaDataClazz, "lscTable", "Ljava/nio/ByteBuffer;");
+    if ( NULL == fields.lscTable ) {
+        LOGE("Couldn't find Metadata field");
+    }
+
+    fields.auxImage = env->GetFieldID(metaDataClazz, "auxImage", "Ljava/nio/ByteBuffer;");
+    if ( NULL == fields.auxImage ) {
+        LOGE("Couldn't find Metadata field");
+    }
+
+    fields.bscRowSum = env->GetFieldID(metaDataClazz, "bscRowSum", "Ljava/nio/ByteBuffer;");
+    if ( NULL == fields.bscRowSum ) {
+        LOGE("Couldn't find Metadata field");
+    }
+
+    fields.bscColSum = env->GetFieldID(metaDataClazz, "bscColSum", "Ljava/nio/ByteBuffer;");
+    if ( NULL == fields.bscColSum ) {
+        LOGE("Couldn't find Metadata field");
+    }
+
+    fields.afPaxelStatistics = env->GetFieldID(metaDataClazz,
+                                               "afPaxelStatistics",
+                                               "Ljava/nio/ByteBuffer;");
+    if ( NULL == fields.afPaxelStatistics ) {
+        LOGE("Couldn't find Metadata field");
+    }
+
+    fields.aewbPaxelStatistics = env->GetFieldID(metaDataClazz,
+                                               "aewbPaxelStatistics",
+                                               "Ljava/nio/ByteBuffer;");
+    if ( NULL == fields.aewbPaxelStatistics ) {
+        LOGE("Couldn't find Metadata field");
+    }
+
+}
+
+static jobject Metadata_retrieveMetadata(JNIEnv* env, jclass clazz, jobject st)
+{
+
+    jclass stClazz = env->FindClass("android/graphics/SurfaceTexture");
+    if (stClazz == NULL) {
+        return NULL;
+    }
+
+    jfieldID context = env->GetFieldID(stClazz,
+                                       ANDROID_GRAPHICS_SURFACETEXTURE_JNI_ID,
+                                       "I");
+    if ( context == NULL ) {
+        return NULL;
+    }
+
+    sp<SurfaceTexture> surfaceTexture = NULL;
+    if ( st != NULL ) {
+        surfaceTexture = reinterpret_cast<SurfaceTexture*>(env->GetIntField(st, context));
+    }
+
+    sp<IMemory> data = surfaceTexture->getMetadata();
+    ssize_t offset;
+    size_t size;
+
+    if ( NULL == data.get() ) {
+        return NULL;
+    }
+
+    sp<IMemoryHeap> heap = data->getMemory(&offset, &size);
+    camera_metadata_t * meta = static_cast<camera_metadata_t *> (heap->base());
+
+    jclass h3aConfigClazz = env->FindClass("com/ti/omap/android/cpcam/CPCamMetadata$H3AConfig");
+    if ( NULL == h3aConfigClazz ) {
+        LOGE("Couldn't find H3AConfig class");
+        return NULL;
+    }
+
+    jclass metaDataClazz = env->FindClass(kMetadataClassPathName);
+    if ( NULL == metaDataClazz ) {
+        LOGE("Couldn't find Metadata class");
+        return NULL;
+    }
+
+    jobject objMeta = (jobject) env->NewObject(metaDataClazz,
+                                               fields.metadataInit);
+    if ( NULL == objMeta ) {
+        LOGE("Couldn't allocate Metadata object");
+        return NULL;
+    }
+
+    if ( 0 < meta->lsc_table_size ) {
+        jobject nioLSCTable = env->NewDirectByteBuffer((uint8_t *)meta + meta->lsc_table_offset,
+                                                  meta->lsc_table_size);
+        if ( NULL == nioLSCTable ) {
+            LOGE("Couldn't allocate NIO LSC table");
+            return NULL;
+        }
+        env->SetObjectField(objMeta, fields.lscTable, nioLSCTable);
+        env->DeleteLocalRef(nioLSCTable);
+        env->SetIntField(objMeta, fields.lscTableApplied, meta->lsc_table_applied);
+    }
+
+    jobject nioFaces = env->NewDirectByteBuffer((uint8_t *)meta + meta->faces_offset,
+                                              meta->number_of_faces * sizeof(camera_metadata_face_t));
+    if ( NULL == nioFaces ) {
+        LOGE("Couldn't allocate NIO Face array");
+        return NULL;
+    }
+    env->SetObjectField(objMeta, fields.faces, nioFaces);
+    env->DeleteLocalRef(nioFaces);
+
+    env->SetIntField(objMeta, fields.numberOfFaces, meta->number_of_faces);
+    env->SetIntField(objMeta, fields.frameNumber, meta->frame_number);
+    env->SetIntField(objMeta, fields.shotNumber, meta->shot_number);
+    env->SetIntField(objMeta, fields.analogGain, meta->analog_gain);
+    env->SetIntField(objMeta, fields.analogGainReq, meta->analog_gain_req);
+    env->SetIntField(objMeta, fields.analogGainMin, meta->analog_gain_min);
+    env->SetIntField(objMeta, fields.analogGainMax, meta->analog_gain_max);
+    env->SetIntField(objMeta, fields.analogGainDev, meta->analog_gain_dev);
+    env->SetIntField(objMeta, fields.analogGainError, meta->analog_gain_error);
+    env->SetIntField(objMeta, fields.exposureTime, meta->exposure_time);
+    env->SetIntField(objMeta, fields.exposureTimeReq, meta->exposure_time_req);
+    env->SetIntField(objMeta, fields.exposureTimeMin, meta->exposure_time_min);
+    env->SetIntField(objMeta, fields.exposureTimeMax, meta->exposure_time_max);
+    env->SetIntField(objMeta, fields.exposureTimeDev, meta->exposure_time_dev);
+    env->SetIntField(objMeta, fields.exposureTimeError, meta->exposure_time_error);
+    env->SetIntField(objMeta, fields.exposureCompensationReq, meta->exposure_compensation_req);
+    env->SetIntField(objMeta, fields.exposureDev, meta->exposure_dev);
+    env->SetLongField(objMeta, fields.timestamp, meta->timestamp);
+    env->SetIntField(objMeta, fields.awbTemp, meta->awb_temp);
+    env->SetIntField(objMeta, fields.gainR, meta->gain_r);
+    env->SetIntField(objMeta, fields.gainGR, meta->gain_gr);
+    env->SetIntField(objMeta, fields.gainGB, meta->gain_gb);
+    env->SetIntField(objMeta, fields.gainB, meta->gain_b);
+    env->SetIntField(objMeta, fields.offsetR, meta->offset_r);
+    env->SetIntField(objMeta, fields.offsetGR, meta->offset_gr);
+    env->SetIntField(objMeta, fields.offsetGB, meta->offset_gb);
+    env->SetIntField(objMeta, fields.offsetB, meta->offset_b);
+
+    return objMeta;
+}
+
+static JNINativeMethod gMetadataMethods[] = {
+    {"nativeClassInit",          "()V", (void*)Metadata_Init },
+    {"nativeRetrieveMetadata",   "(Landroid/graphics/SurfaceTexture;)Lcom/ti/omap/android/cpcam/CPCamMetadata;", (void*)Metadata_retrieveMetadata },
+};
+
+int register_com_ti_omap_android_cpcam_CPCamMetadata(JNIEnv* env)
+{
+    int err = 0;
+    err = AndroidRuntime::registerNativeMethods(env,
+                                                kMetadataClassPathName,
+                                                gMetadataMethods,
+                                                NELEM(gMetadataMethods));
+    return err;
+}