CameraHal: Add external gamma table configuration

- Added support to set external gamma table.
  Application can set camera parameter with key "gamma-table"
  and value in the form:
  "(OffsetR0:SlopeR0,OffsetR1:SlopeR1,...,OffsetRN:SlopeRN),"
  "(OffsetG0:SlopeG0,OffsetG1:SlopeG1,...,OffsetGN:SlopeGN),"
  "(OffsetB0:SlopeB0,OffsetB1:SlopeB1,...,OffsetBN:SlopeBN)"

Depends on hardware/ti/domx change I199d28e2:
http://review.omapzoom.org/#/c/27885/

Change-Id: I5dabde9b693cf8cb501ec8584729cd4fa174939c
Signed-off-by: Vladimir Petrov <vppetrov@mm-sol.com>

7 files changed, 202 insertions, 16 deletions

diff --git a/camera/CameraHal.cpp b/camera/CameraHal.cpp
index 53f4963..7754d51 100644
--- a/camera/CameraHal.cpp
+++ b/camera/CameraHal.cpp
@@ -1136,10 +1136,10 @@ int CameraHal::setParameters(const android::CameraParameters& params)
         }
 
         //TI extensions for enable/disable algos
-        if( (valstr = params.get(TICameraParameters::KEY_ALGO_FIXED_GAMMA)) != NULL )
+        if( (valstr = params.get(TICameraParameters::KEY_ALGO_EXTERNAL_GAMMA)) != NULL )
             {
-            CAMHAL_LOGDB("Fixed Gamma set %s", valstr);
-            mParameters.set(TICameraParameters::KEY_ALGO_FIXED_GAMMA, valstr);
+            CAMHAL_LOGDB("External Gamma set %s", valstr);
+            mParameters.set(TICameraParameters::KEY_ALGO_EXTERNAL_GAMMA, valstr);
             }
 
         if( (valstr = params.get(TICameraParameters::KEY_ALGO_NSF1)) != NULL )
@@ -1172,6 +1172,12 @@ int CameraHal::setParameters(const android::CameraParameters& params)
             mParameters.set(TICameraParameters::KEY_ALGO_GIC, valstr);
             }
 
+        if( (valstr = params.get(TICameraParameters::KEY_GAMMA_TABLE)) != NULL )
+            {
+            CAMHAL_LOGDB("Manual gamma table set %s", valstr);
+            mParameters.set(TICameraParameters::KEY_GAMMA_TABLE, valstr);
+            }
+
         android::CameraParameters adapterParams = mParameters;
 
 #ifdef OMAP_ENHANCEMENT
@@ -4550,7 +4556,7 @@ void CameraHal::initDefaultParameters()
 
     // TI extensions for enable/disable algos
     // Hadcoded for now
-    p.set(TICameraParameters::KEY_ALGO_FIXED_GAMMA, android::CameraParameters::TRUE);
+    p.set(TICameraParameters::KEY_ALGO_EXTERNAL_GAMMA, android::CameraParameters::FALSE);
     p.set(TICameraParameters::KEY_ALGO_NSF1, android::CameraParameters::TRUE);
     p.set(TICameraParameters::KEY_ALGO_NSF2, android::CameraParameters::TRUE);
     p.set(TICameraParameters::KEY_ALGO_SHARPENING, android::CameraParameters::TRUE);
diff --git a/camera/OMXCameraAdapter/OMX3A.cpp b/camera/OMXCameraAdapter/OMX3A.cpp
index 8192034..9baad08 100644
--- a/camera/OMXCameraAdapter/OMX3A.cpp
+++ b/camera/OMXCameraAdapter/OMX3A.cpp
@@ -388,8 +388,8 @@ status_t OMXCameraAdapter::setParameters3A(const android::CameraParameters &para
     }
 
 // TI extensions for enable/disable algos
-    declareParameter3ABool(params, TICameraParameters::KEY_ALGO_FIXED_GAMMA,
-                       mParameters3A.AlgoFixedGamma, SetAlgoFixedGamma, "Fixed Gamma");
+    declareParameter3ABool(params, TICameraParameters::KEY_ALGO_EXTERNAL_GAMMA,
+                       mParameters3A.AlgoExternalGamma, SetAlgoExternalGamma, "External Gamma");
     declareParameter3ABool(params, TICameraParameters::KEY_ALGO_NSF1,
                        mParameters3A.AlgoNSF1, SetAlgoNSF1, "NSF1");
     declareParameter3ABool(params, TICameraParameters::KEY_ALGO_NSF2,
@@ -400,11 +400,92 @@ status_t OMXCameraAdapter::setParameters3A(const android::CameraParameters &para
                        mParameters3A.AlgoThreeLinColorMap, SetAlgoThreeLinColorMap, "ThreeLinColorMap");
     declareParameter3ABool(params, TICameraParameters::KEY_ALGO_GIC, mParameters3A.AlgoGIC, SetAlgoGIC, "GIC");
 
+    // Gamma table
+    str = params.get(TICameraParameters::KEY_GAMMA_TABLE);
+    updateGammaTable(str);
+
     LOG_FUNCTION_NAME_EXIT;
 
     return ret;
 }
 
+void OMXCameraAdapter::updateGammaTable(const char* gamma)
+{
+    unsigned int plane = 0;
+    unsigned int i = 0;
+    bool gamma_changed = false;
+    const char *a = gamma;
+    OMX_TI_GAMMATABLE_ELEM_TYPE *elem[3] = { mParameters3A.mGammaTable.pR,
+                                             mParameters3A.mGammaTable.pG,
+                                             mParameters3A.mGammaTable.pB};
+
+    if (!gamma) return;
+
+    mPending3Asettings &= ~SetGammaTable;
+    memset(&mParameters3A.mGammaTable, 0, sizeof(mParameters3A.mGammaTable));
+    for (plane = 0; plane < 3; plane++) {
+        a = strchr(a, '(');
+        if (NULL != a) {
+            a++;
+            for (i = 0; i < OMX_TI_GAMMATABLE_SIZE; i++) {
+                char *b;
+                int newVal;
+                newVal = strtod(a, &b);
+                if (newVal != elem[plane][i].nOffset) {
+                    elem[plane][i].nOffset = newVal;
+                    gamma_changed = true;
+                }
+                a = strpbrk(b, ",:)");
+                if ((NULL != a) && (':' == *a)) {
+                    a++;
+                } else if ((NULL != a) && (',' == *a)){
+                    a++;
+                    break;
+                } else if ((NULL != a) && (')' == *a)){
+                    a++;
+                    break;
+                } else {
+                    CAMHAL_LOGE("Error while parsing values");
+                    gamma_changed = false;
+                    break;
+                }
+                newVal = strtod(a, &b);
+                if (newVal != elem[plane][i].nSlope) {
+                    elem[plane][i].nSlope = newVal;
+                    gamma_changed = true;
+                }
+                a = strpbrk(b, ",:)");
+                if ((NULL != a) && (',' == *a)) {
+                    a++;
+                } else if ((NULL != a) && (':' == *a)){
+                    a++;
+                    break;
+                } else if ((NULL != a) && (')' == *a)){
+                    a++;
+                    break;
+                } else {
+                    CAMHAL_LOGE("Error while parsing values");
+                    gamma_changed = false;
+                    break;
+                }
+            }
+            if ((OMX_TI_GAMMATABLE_SIZE - 1) != i) {
+                CAMHAL_LOGE("Error while parsing values (incorrect count %u)", i);
+                gamma_changed = false;
+                break;
+            }
+        } else {
+            CAMHAL_LOGE("Error while parsing planes (%u)", plane);
+            gamma_changed = false;
+            break;
+        }
+    }
+
+    if (gamma_changed) {
+        mPending3Asettings |= SetGammaTable;
+    }
+}
+
 void OMXCameraAdapter::declareParameter3ABool(const android::CameraParameters &params, const char *key,
                                               OMX_BOOL &current_setting, E3ASettingsFlags pending,
                                               const char *msg)
@@ -1767,9 +1848,9 @@ status_t OMXCameraAdapter::setParameter3ABool(const OMX_INDEXTYPE omx_idx,
   return Utils::ErrorUtils::omxToAndroidError(eError);
 }
 
-status_t OMXCameraAdapter::setAlgoFixedGamma(Gen3A_settings& Gen3A)
+status_t OMXCameraAdapter::setAlgoExternalGamma(Gen3A_settings& Gen3A)
 {
-    return setParameter3ABool((OMX_INDEXTYPE) OMX_TI_IndexConfigFixedGamma, Gen3A.AlgoFixedGamma, "Fixed Gamma");
+    return setParameter3ABool((OMX_INDEXTYPE) OMX_TI_IndexConfigExternalGamma, Gen3A.AlgoExternalGamma, "External Gamma");
 }
 
 status_t OMXCameraAdapter::setAlgoNSF1(Gen3A_settings& Gen3A)
@@ -1797,6 +1878,86 @@ status_t OMXCameraAdapter::setAlgoGIC(Gen3A_settings& Gen3A)
     return setParameter3ABoolInvert((OMX_INDEXTYPE) OMX_TI_IndexConfigDisableGIC, Gen3A.AlgoGIC, "Green Inballance Correction");
 }
 
+status_t OMXCameraAdapter::setGammaTable(Gen3A_settings& Gen3A)
+{
+    status_t ret = NO_ERROR;
+    OMX_ERRORTYPE eError = OMX_ErrorNone;
+    CameraBuffer *bufferlist = NULL;
+    OMX_TI_CONFIG_GAMMATABLE_TYPE *gammaTable = NULL;
+    OMX_TI_CONFIG_SHAREDBUFFER sharedBuffer;
+    int tblSize = 0;
+
+    LOG_FUNCTION_NAME;
+
+    if ( OMX_StateInvalid == mComponentState ) {
+        CAMHAL_LOGEA("OMX component is in invalid state");
+        ret = NO_INIT;
+        goto EXIT;
+    }
+
+    tblSize = ((sizeof(OMX_TI_CONFIG_GAMMATABLE_TYPE)+4095)/4096)*4096;
+    bufferlist = mMemMgr.allocateBufferList(0, 0, NULL, tblSize, 1);
+    if (NULL == bufferlist) {
+        CAMHAL_LOGEB("Error allocating buffer for gamma table");
+        ret =  NO_MEMORY;
+        goto EXIT;
+    }
+    gammaTable = (OMX_TI_CONFIG_GAMMATABLE_TYPE *)bufferlist[0].mapped;
+    if (NULL == gammaTable) {
+        CAMHAL_LOGEB("Error allocating buffer for gamma table (wrong data pointer)");
+        ret =  NO_MEMORY;
+        goto EXIT;
+    }
+
+    memcpy(gammaTable, &mParameters3A.mGammaTable, sizeof(OMX_TI_CONFIG_GAMMATABLE_TYPE));
+
+#ifdef CAMERAHAL_DEBUG
+    {
+        android::String8 DmpR;
+        android::String8 DmpG;
+        android::String8 DmpB;
+        for (unsigned int i=0; i<OMX_TI_GAMMATABLE_SIZE;i++) {
+            DmpR.appendFormat(" %d:%d;", (int)gammaTable->pR[i].nOffset, (int)(int)gammaTable->pR[i].nSlope);
+            DmpG.appendFormat(" %d:%d;", (int)gammaTable->pG[i].nOffset, (int)(int)gammaTable->pG[i].nSlope);
+            DmpB.appendFormat(" %d:%d;", (int)gammaTable->pB[i].nOffset, (int)(int)gammaTable->pB[i].nSlope);
+        }
+        CAMHAL_LOGE("Gamma table R:%s", DmpR.string());
+        CAMHAL_LOGE("Gamma table G:%s", DmpG.string());
+        CAMHAL_LOGE("Gamma table B:%s", DmpB.string());
+    }
+#endif
+
+    OMX_INIT_STRUCT_PTR (&sharedBuffer, OMX_TI_CONFIG_SHAREDBUFFER);
+    sharedBuffer.nPortIndex = OMX_ALL;
+    sharedBuffer.nSharedBuffSize = sizeof(OMX_TI_CONFIG_GAMMATABLE_TYPE);
+    sharedBuffer.pSharedBuff = (OMX_U8 *)camera_buffer_get_omx_ptr (&bufferlist[0]);
+    if ( NULL == sharedBuffer.pSharedBuff ) {
+        CAMHAL_LOGEA("No resources to allocate OMX shared buffer");
+        ret = NO_MEMORY;
+        goto EXIT;
+    }
+
+    eError =  OMX_SetConfig(mCameraAdapterParameters.mHandleComp,
+                            (OMX_INDEXTYPE) OMX_TI_IndexConfigGammaTable, &sharedBuffer);
+    if ( OMX_ErrorNone != eError ) {
+        CAMHAL_LOGEB("Error while setting Gamma Table configuration 0x%x", eError);
+        ret = BAD_VALUE;
+        goto EXIT;
+    } else {
+        CAMHAL_LOGDA("Gamma Table SetConfig successfull.");
+    }
+
+EXIT:
+
+    if (NULL != bufferlist) {
+        mMemMgr.freeBufferList(bufferlist);
+    }
+
+    LOG_FUNCTION_NAME_EXIT;
+
+    return ret;
+}
+
 status_t OMXCameraAdapter::apply3Asettings( Gen3A_settings& Gen3A )
 {
     status_t ret = NO_ERROR;
@@ -1932,9 +2093,9 @@ status_t OMXCameraAdapter::apply3Asettings( Gen3A_settings& Gen3A )
                   break;
 
                 //TI extensions for enable/disable algos
-                case SetAlgoFixedGamma:
+                case SetAlgoExternalGamma:
                   {
-                    ret |= setAlgoFixedGamma(Gen3A);
+                    ret |= setAlgoExternalGamma(Gen3A);
                   }
                   break;
 
@@ -1968,6 +2129,12 @@ status_t OMXCameraAdapter::apply3Asettings( Gen3A_settings& Gen3A )
                   }
                   break;
 
+                case SetGammaTable:
+                  {
+                    ret |= setGammaTable(Gen3A);
+                  }
+                  break;
+
                 default:
                     CAMHAL_LOGEB("this setting (0x%x) is still not supported in CameraAdapter ",
                                  currSett);
diff --git a/camera/OMXCameraAdapter/OMXCameraAdapter.cpp b/camera/OMXCameraAdapter/OMXCameraAdapter.cpp
index 6f89ca0..9f6dd37 100644
--- a/camera/OMXCameraAdapter/OMXCameraAdapter.cpp
+++ b/camera/OMXCameraAdapter/OMXCameraAdapter.cpp
@@ -377,12 +377,13 @@ status_t OMXCameraAdapter::initialize(CameraProperties::Properties* caps)
     mParameters3A.ManualGain = 0;
     mParameters3A.ManualGainRight = 0;
 
-    mParameters3A.AlgoFixedGamma = OMX_TRUE;
+    mParameters3A.AlgoExternalGamma = OMX_FALSE;
     mParameters3A.AlgoNSF1 = OMX_TRUE;
     mParameters3A.AlgoNSF2 = OMX_TRUE;
     mParameters3A.AlgoSharpening = OMX_TRUE;
     mParameters3A.AlgoThreeLinColorMap = OMX_TRUE;
     mParameters3A.AlgoGIC = OMX_TRUE;
+    memset(&mParameters3A.mGammaTable, 0, sizeof(mParameters3A.mGammaTable));
 
     LOG_FUNCTION_NAME_EXIT;
     return Utils::ErrorUtils::omxToAndroidError(eError);
diff --git a/camera/TICameraParameters.cpp b/camera/TICameraParameters.cpp
index 2aa0ac9..ae8cd81 100644
--- a/camera/TICameraParameters.cpp
+++ b/camera/TICameraParameters.cpp
@@ -221,12 +221,14 @@ const char TICameraParameters::KEY_MECHANICAL_MISALIGNMENT_CORRECTION_SUPPORTED[
 const char TICameraParameters::KEY_MECHANICAL_MISALIGNMENT_CORRECTION[] = "mechanical-misalignment-correction";
 
 //TI extensions for enable/disable algos
-const char TICameraParameters::KEY_ALGO_FIXED_GAMMA[] = TI_KEY_ALGO_PREFIX "fixed-gamma";
+const char TICameraParameters::KEY_ALGO_EXTERNAL_GAMMA[] = TI_KEY_ALGO_PREFIX "external-gamma";
 const char TICameraParameters::KEY_ALGO_NSF1[] = TI_KEY_ALGO_PREFIX "nsf1";
 const char TICameraParameters::KEY_ALGO_NSF2[] = TI_KEY_ALGO_PREFIX "nsf2";
 const char TICameraParameters::KEY_ALGO_SHARPENING[] = TI_KEY_ALGO_PREFIX "sharpening";
 const char TICameraParameters::KEY_ALGO_THREELINCOLORMAP[] = TI_KEY_ALGO_PREFIX "threelinecolormap";
 const char TICameraParameters::KEY_ALGO_GIC[] = TI_KEY_ALGO_PREFIX "gic";
 
+const char TICameraParameters::KEY_GAMMA_TABLE[] = "gamma-table";
+
 } // namespace Camera
 } // namespace Ti
diff --git a/camera/inc/General3A_Settings.h b/camera/inc/General3A_Settings.h
index 777b255..c1e017c 100644
--- a/camera/inc/General3A_Settings.h
+++ b/camera/inc/General3A_Settings.h
@@ -241,13 +241,15 @@ class Gen3A_settings{
     OMX_BOOL FocusLock;
     OMX_BOOL WhiteBalanceLock;
 
-    OMX_BOOL AlgoFixedGamma;
+    OMX_BOOL AlgoExternalGamma;
     OMX_BOOL AlgoNSF1;
     OMX_BOOL AlgoNSF2;
     OMX_BOOL AlgoSharpening;
     OMX_BOOL AlgoThreeLinColorMap;
     OMX_BOOL AlgoGIC;
 
+    OMX_TI_CONFIG_GAMMATABLE_TYPE mGammaTable;
+
 };
 
 /*
@@ -274,12 +276,13 @@ enum E3ASettingsFlags
     SetMeteringAreas        = 1 << 18,
     SetManualExposure       = 1 << 19,
 
-    SetAlgoFixedGamma       = 1 << 20,
+    SetAlgoExternalGamma    = 1 << 20,
     SetAlgoNSF1             = 1 << 21,
     SetAlgoNSF2             = 1 << 22,
     SetAlgoSharpening       = 1 << 23,
     SetAlgoThreeLinColorMap = 1 << 24,
     SetAlgoGIC              = 1 << 25,
+    SetGammaTable           = 1 << 26,
 
 
     E3aSettingMax,
diff --git a/camera/inc/OMXCameraAdapter/OMXCameraAdapter.h b/camera/inc/OMXCameraAdapter/OMXCameraAdapter.h
index fa73918..b2da574 100644
--- a/camera/inc/OMXCameraAdapter/OMXCameraAdapter.h
+++ b/camera/inc/OMXCameraAdapter/OMXCameraAdapter.h
@@ -579,13 +579,17 @@ private:
                                 const OMX_BOOL data, const char *msg);
     status_t setParameter3ABoolInvert(const OMX_INDEXTYPE omx_idx,
                                       const OMX_BOOL data, const char *msg);
-    status_t setAlgoFixedGamma(Gen3A_settings& Gen3A);
+    status_t setAlgoExternalGamma(Gen3A_settings& Gen3A);
     status_t setAlgoNSF1(Gen3A_settings& Gen3A);
     status_t setAlgoNSF2(Gen3A_settings& Gen3A);
     status_t setAlgoSharpening(Gen3A_settings& Gen3A);
     status_t setAlgoThreeLinColorMap(Gen3A_settings& Gen3A);
     status_t setAlgoGIC(Gen3A_settings& Gen3A);
 
+    //Gamma table
+    void updateGammaTable(const char* gamma);
+    status_t setGammaTable(Gen3A_settings& Gen3A);
+
     status_t getEVCompensation(Gen3A_settings& Gen3A);
     status_t getWBMode(Gen3A_settings& Gen3A);
     status_t getSharpness(Gen3A_settings& Gen3A);
diff --git a/camera/inc/TICameraParameters.h b/camera/inc/TICameraParameters.h
index a2abaa6..c5a24e9 100644
--- a/camera/inc/TICameraParameters.h
+++ b/camera/inc/TICameraParameters.h
@@ -245,13 +245,16 @@ static const char KEY_MECHANICAL_MISALIGNMENT_CORRECTION_SUPPORTED[];
 static const char KEY_MECHANICAL_MISALIGNMENT_CORRECTION[];
 
 //TI extensions for enable/disable algos
-static const char KEY_ALGO_FIXED_GAMMA[];
+static const char KEY_ALGO_EXTERNAL_GAMMA[];
 static const char KEY_ALGO_NSF1[];
 static const char KEY_ALGO_NSF2[];
 static const char KEY_ALGO_SHARPENING[];
 static const char KEY_ALGO_THREELINCOLORMAP[];
 static const char KEY_ALGO_GIC[];
 
+//Gamma table
+static const char KEY_GAMMA_TABLE[];
+
 };
 
 } // namespace Camera