mm-video-v4l2: venc: Support for encoder MB based slice spacing

Support is added in video encoder component to configure
macroblock (MB) based slice header spacing.
And also updated byte based slice header spacing.

CRs-Fixed: 2067990
Change-Id: I99b2d8db49ef01299e8115886c6e27ef9858f125

6 files changed, 84 insertions, 15 deletions

diff --git a/mm-video-v4l2/vidc/common/inc/vidc_vendor_extensions.h b/mm-video-v4l2/vidc/common/inc/vidc_vendor_extensions.h
index 1583b189..2f9e1d62 100644
--- a/mm-video-v4l2/vidc/common/inc/vidc_vendor_extensions.h
+++ b/mm-video-v4l2/vidc/common/inc/vidc_vendor_extensions.h
@@ -157,6 +157,9 @@ struct VendorExtension {
     // Must be called to check whether config data provided with setConfig is valid
     OMX_ERRORTYPE isConfigValid(OMX_CONFIG_ANDROID_VENDOR_EXTENSIONTYPE *ext) const;
 
+    // Compare the keys for correct configuration
+    bool isConfigKey(OMX_CONFIG_ANDROID_VENDOR_EXTENSIONTYPE *ext, const char *paramKey) const;
+
     // utils
     static const char* typeString(OMX_ANDROID_VENDOR_VALUETYPE type);
     std::string debugString() const;
diff --git a/mm-video-v4l2/vidc/common/src/vidc_vendor_extensions.cpp b/mm-video-v4l2/vidc/common/src/vidc_vendor_extensions.cpp
index ad578ea7..3b06bc7c 100644
--- a/mm-video-v4l2/vidc/common/src/vidc_vendor_extensions.cpp
+++ b/mm-video-v4l2/vidc/common/src/vidc_vendor_extensions.cpp
@@ -178,6 +178,18 @@ OMX_ERRORTYPE VendorExtension::isConfigValid(
     return OMX_ErrorNone;
 }
 
+bool VendorExtension::isConfigKey(
+         OMX_CONFIG_ANDROID_VENDOR_EXTENSIONTYPE *ext,
+         const char *paramKey) const {
+
+    bool retStatus = false;
+    if (!strncmp((char *)ext->cName, paramKey, OMX_MAX_STRINGNAME_SIZE)) {
+        retStatus = true;
+    }
+
+    return retStatus;
+}
+
 //static
 const char* VendorExtension::typeString(OMX_ANDROID_VENDOR_VALUETYPE type) {
     switch (type) {
diff --git a/mm-video-v4l2/vidc/venc/inc/omx_video_base.h b/mm-video-v4l2/vidc/venc/inc/omx_video_base.h
index 8210b7fe..af108f7a 100644
--- a/mm-video-v4l2/vidc/venc/inc/omx_video_base.h
+++ b/mm-video-v4l2/vidc/venc/inc/omx_video_base.h
@@ -660,6 +660,7 @@ class omx_video: public qc_omx_component
         OMX_VIDEO_PARAM_AVCSLICEFMO m_sAVCSliceFMO;
         QOMX_VIDEO_INTRAPERIODTYPE m_sIntraperiod;
         OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE m_sErrorCorrection;
+        QOMX_VIDEO_PARAM_SLICE_SPACING_TYPE m_sSliceSpacing;
         OMX_VIDEO_PARAM_INTRAREFRESHTYPE m_sIntraRefresh;
         QOMX_VIDEO_PARAM_LTRMODE_TYPE m_sParamLTRMode;
         QOMX_VIDEO_PARAM_LTRCOUNT_TYPE m_sParamLTRCount;
diff --git a/mm-video-v4l2/vidc/venc/src/omx_video_encoder.cpp b/mm-video-v4l2/vidc/venc/src/omx_video_encoder.cpp
index e3296a65..ac48cbb9 100644
--- a/mm-video-v4l2/vidc/venc/src/omx_video_encoder.cpp
+++ b/mm-video-v4l2/vidc/venc/src/omx_video_encoder.cpp
@@ -232,6 +232,10 @@ OMX_ERRORTYPE omx_venc::component_init(OMX_STRING role)
     m_sErrorCorrection.bEnableRVLC = OMX_FALSE;
     m_sErrorCorrection.nResynchMarkerSpacing = 0;
 
+    OMX_INIT_STRUCT(&m_sSliceSpacing, QOMX_VIDEO_PARAM_SLICE_SPACING_TYPE);
+    m_sSliceSpacing.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
+    m_sSliceSpacing.eSliceMode = QOMX_SLICEMODE_MB_COUNT;
+
     OMX_INIT_STRUCT(&m_sIntraRefresh, OMX_VIDEO_PARAM_INTRAREFRESHTYPE);
     m_sIntraRefresh.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
     m_sIntraRefresh.eRefreshMode = OMX_VIDEO_IntraRefreshMax;
@@ -1023,6 +1027,19 @@ OMX_ERRORTYPE  omx_venc::set_parameter(OMX_IN OMX_HANDLETYPE     hComp,
                 memcpy(&m_sErrorCorrection,pParam, sizeof(m_sErrorCorrection));
                 break;
             }
+        case OMX_QcomIndexParamVideoSliceSpacing:
+            {
+                VALIDATE_OMX_PARAM_DATA(paramData, QOMX_VIDEO_PARAM_SLICE_SPACING_TYPE);
+                DEBUG_PRINT_LOW("OMX_QcomIndexParamVideoSliceSpacing");
+                QOMX_VIDEO_PARAM_SLICE_SPACING_TYPE* pParam =
+                    (QOMX_VIDEO_PARAM_SLICE_SPACING_TYPE*)paramData;
+                if (!handle->venc_set_param(paramData, (OMX_INDEXTYPE)OMX_QcomIndexParamVideoSliceSpacing)) {
+                    DEBUG_PRINT_ERROR("ERROR: Request for setting slice spacing failed");
+                    return OMX_ErrorUnsupportedSetting;
+                }
+                memcpy(&m_sSliceSpacing, pParam, sizeof(m_sSliceSpacing));
+                break;
+            }
         case OMX_IndexParamVideoIntraRefresh:
             {
                 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_INTRAREFRESHTYPE);
diff --git a/mm-video-v4l2/vidc/venc/src/omx_video_extensions.hpp b/mm-video-v4l2/vidc/venc/src/omx_video_extensions.hpp
index ebbe2878..83832b51 100644
--- a/mm-video-v4l2/vidc/venc/src/omx_video_extensions.hpp
+++ b/mm-video-v4l2/vidc/venc/src/omx_video_extensions.hpp
@@ -38,9 +38,12 @@ void omx_video::init_vendor_extensions(VendorExtensionStore &store) {
     ADD_PARAM    ("n-pframes",    OMX_AndroidVendorValueInt32)
     ADD_PARAM_END("n-idr-period", OMX_AndroidVendorValueInt32)
 
-    ADD_EXTENSION("qti-ext-enc-error-correction", OMX_IndexParamVideoErrorCorrection, OMX_DirOutput)
+    ADD_EXTENSION("qti-ext-enc-error-correction", OMX_QcomIndexParamVideoSliceSpacing, OMX_DirOutput)
     ADD_PARAM_END("resync-marker-spacing-bits", OMX_AndroidVendorValueInt32)
 
+    ADD_EXTENSION("qti-ext-enc-slice", OMX_QcomIndexParamVideoSliceSpacing, OMX_DirOutput)
+    ADD_PARAM_END("spacing", OMX_AndroidVendorValueInt32)
+
     ADD_EXTENSION("qti-ext-enc-custom-profile-level", OMX_IndexParamVideoProfileLevelCurrent, OMX_DirOutput)
     ADD_PARAM    ("profile", OMX_AndroidVendorValueInt32)
     ADD_PARAM_END("level",   OMX_AndroidVendorValueInt32)
@@ -97,11 +100,14 @@ OMX_ERRORTYPE omx_video::get_vendor_extension_config(
             setStatus &= vExt.setParamInt32(ext, "n-idr-period", m_sConfigAVCIDRPeriod.nIDRPeriod);
             break;
         }
-        case OMX_IndexParamVideoErrorCorrection:
+        case OMX_QcomIndexParamVideoSliceSpacing:
         {
-            // "bits" @0
-            setStatus &= vExt.setParamInt32(ext,
-                    "resync-marker-spacing-bits", m_sErrorCorrection.nResynchMarkerSpacing);
+            if (vExt.isConfigKey(ext, "qti-ext-enc-error-correction")) {
+                setStatus &= vExt.setParamInt32(ext,
+                        "resync-marker-spacing-bits", m_sSliceSpacing.nSliceSize);
+            } else if (vExt.isConfigKey(ext, "qti-ext-enc-slice")) {
+                setStatus &= vExt.setParamInt32(ext, "spacing", m_sSliceSpacing.nSliceSize);
+            }
             break;
         }
         case OMX_IndexParamVideoProfileLevelCurrent:
@@ -214,23 +220,36 @@ OMX_ERRORTYPE omx_video::set_vendor_extension_config(
             }
             break;
         }
-        case OMX_IndexParamVideoErrorCorrection:
+        case OMX_QcomIndexParamVideoSliceSpacing:
         {
-            OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE ecParam;
-            memcpy(&ecParam, &m_sErrorCorrection, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
-            valueSet |= vExt.readParamInt32(ext,
-                    "resync-marker-spacing-bits", (OMX_S32 *)&(ecParam.nResynchMarkerSpacing));
+            QOMX_VIDEO_PARAM_SLICE_SPACING_TYPE sliceSpacing;
+            memcpy(&sliceSpacing, &m_sSliceSpacing, sizeof(QOMX_VIDEO_PARAM_SLICE_SPACING_TYPE));
+
+            if (vExt.isConfigKey(ext, "qti-ext-enc-error-correction")) {
+                sliceSpacing.eSliceMode = QOMX_SLICEMODE_BYTE_COUNT;
+                valueSet |= vExt.readParamInt32(ext,
+                    "resync-marker-spacing-bits", (OMX_S32 *)&(sliceSpacing.nSliceSize));
+                sliceSpacing.nSliceSize = ALIGN(sliceSpacing.nSliceSize, 8) >> 3;
+            } else if (vExt.isConfigKey(ext, "qti-ext-enc-slice")) {
+                sliceSpacing.eSliceMode = QOMX_SLICEMODE_MB_COUNT;
+                valueSet |= vExt.readParamInt32(ext,
+                    "spacing", (OMX_S32 *)&(sliceSpacing.nSliceSize));
+            } else {
+              DEBUG_PRINT_ERROR("VENDOR-EXT: set_config: Slice Spacing : Incorrect Mode !");
+              break;
+            }
+
             if (!valueSet) {
                 break;
             }
 
-            DEBUG_PRINT_HIGH("VENDOR-EXT: set_config: resync-marker-spacing : %d bits",
-                    ecParam.nResynchMarkerSpacing);
+            DEBUG_PRINT_HIGH("VENDOR-EXT: set_config: slice spacing : mode %d size %d",
+                    sliceSpacing.eSliceMode, sliceSpacing.nSliceSize);
 
             err = set_parameter(
-                    NULL, OMX_IndexParamVideoErrorCorrection, &ecParam);
+                    NULL, (OMX_INDEXTYPE)OMX_QcomIndexParamVideoSliceSpacing, &sliceSpacing);
             if (err != OMX_ErrorNone) {
-                DEBUG_PRINT_ERROR("set_config: OMX_IndexParamVideoErrorCorrection failed !");
+                DEBUG_PRINT_ERROR("set_config: OMX_QcomIndexParamVideoSliceSpacing failed !");
             }
             break;
         }
diff --git a/mm-video-v4l2/vidc/venc/src/video_encoder_device_v4l2.cpp b/mm-video-v4l2/vidc/venc/src/video_encoder_device_v4l2.cpp
index 30d2750a..055352f8 100644
--- a/mm-video-v4l2/vidc/venc/src/video_encoder_device_v4l2.cpp
+++ b/mm-video-v4l2/vidc/venc/src/video_encoder_device_v4l2.cpp
@@ -2067,7 +2067,7 @@ bool venc_dev::venc_set_param(void *paramData, OMX_INDEXTYPE index)
 
                 if (error_resilience->nPortIndex == (OMX_U32) PORT_INDEX_OUT) {
                     if (venc_set_error_resilience(error_resilience) == false) {
-                        DEBUG_PRINT_ERROR("ERROR: Setting Intra refresh failed");
+                        DEBUG_PRINT_ERROR("ERROR: Setting Error Correction failed");
                         return false;
                     }
                 } else {
@@ -2076,6 +2076,23 @@ bool venc_dev::venc_set_param(void *paramData, OMX_INDEXTYPE index)
 
                 break;
             }
+         case OMX_QcomIndexParamVideoSliceSpacing:
+            {
+                DEBUG_PRINT_LOW("venc_set_param:OMX_QcomIndexParamVideoSliceSpacing");
+                QOMX_VIDEO_PARAM_SLICE_SPACING_TYPE *slice_spacing =
+                    (QOMX_VIDEO_PARAM_SLICE_SPACING_TYPE*)paramData;
+
+                if (slice_spacing->nPortIndex == (OMX_U32) PORT_INDEX_OUT) {
+                    if (!venc_set_multislice_cfg(slice_spacing->eSliceMode, slice_spacing->nSliceSize)) {
+                        DEBUG_PRINT_ERROR("ERROR: Setting Slice Spacing failed");
+                        return false;
+                    }
+                } else {
+                    DEBUG_PRINT_ERROR("ERROR: Invalid Port Index for OMX_QcomIndexParamVideoSliceSpacing");
+                }
+
+                break;
+            }
         case OMX_IndexParamVideoProfileLevelCurrent:
             {
                 DEBUG_PRINT_LOW("venc_set_param:OMX_IndexParamVideoProfileLevelCurrent");