Revert "Loop all decode tests for all port modes supported"

This reverts commit 3864db6b0d8f845f9e39d5242e91a11999ebfcde.

Change-Id: Ia8913ce11811a5b0037f9683118c0d5c5bbc4e42

5 files changed, 439 insertions, 547 deletions

diff --git a/media/omx/1.0/vts/functional/audio/VtsHalMediaOmxV1_0TargetAudioDecTest.cpp b/media/omx/1.0/vts/functional/audio/VtsHalMediaOmxV1_0TargetAudioDecTest.cpp
index 369db5b6..b8a16344 100644
--- a/media/omx/1.0/vts/functional/audio/VtsHalMediaOmxV1_0TargetAudioDecTest.cpp
+++ b/media/omx/1.0/vts/functional/audio/VtsHalMediaOmxV1_0TargetAudioDecTest.cpp
@@ -813,7 +813,7 @@ TEST_F(AudioDecHidlTest, DecodeTest) {
     if (timestampDevTest) EXPECT_EQ(timestampUslist.empty(), true);
     // set state to idle
     changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
-    // set state to loaded
+    // set state to executing
     changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
                             kPortIndexInput, kPortIndexOutput);
 }
@@ -872,7 +872,7 @@ TEST_F(AudioDecHidlTest, EOSTest_M) {
 
     // set state to idle
     changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
-    // set state to loaded
+    // set state to executing
     changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
                             kPortIndexInput, kPortIndexOutput);
 }
@@ -979,7 +979,7 @@ TEST_F(AudioDecHidlTest, ThumbnailTest) {
 
     // set state to idle
     changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
-    // set state to loaded
+    // set state to executing
     changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
                             kPortIndexInput, kPortIndexOutput);
 }
@@ -1065,7 +1065,7 @@ TEST_F(AudioDecHidlTest, SimpleEOSTest) {
 
     // set state to idle
     changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
-    // set state to loaded
+    // set state to executing
     changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
                             kPortIndexInput, kPortIndexOutput);
 }
@@ -1169,7 +1169,7 @@ TEST_F(AudioDecHidlTest, FlushTest) {
 
     // set state to idle
     changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
-    // set state to loaded
+    // set state to executing
     changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
                             kPortIndexInput, kPortIndexOutput);
 }
diff --git a/media/omx/1.0/vts/functional/audio/VtsHalMediaOmxV1_0TargetAudioEncTest.cpp b/media/omx/1.0/vts/functional/audio/VtsHalMediaOmxV1_0TargetAudioEncTest.cpp
index 5367a4d5..dd5f16af 100644
--- a/media/omx/1.0/vts/functional/audio/VtsHalMediaOmxV1_0TargetAudioEncTest.cpp
+++ b/media/omx/1.0/vts/functional/audio/VtsHalMediaOmxV1_0TargetAudioEncTest.cpp
@@ -535,7 +535,7 @@ TEST_F(AudioEncHidlTest, SimpleEncodeTest) {
 
     // set state to idle
     changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
-    // set state to loaded
+    // set state to executing
     changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
                             kPortIndexInput, kPortIndexOutput);
 }
diff --git a/media/omx/1.0/vts/functional/video/VtsHalMediaOmxV1_0TargetVideoDecTest.cpp b/media/omx/1.0/vts/functional/video/VtsHalMediaOmxV1_0TargetVideoDecTest.cpp
index eeca5997..070dc4c1 100644
--- a/media/omx/1.0/vts/functional/video/VtsHalMediaOmxV1_0TargetVideoDecTest.cpp
+++ b/media/omx/1.0/vts/functional/video/VtsHalMediaOmxV1_0TargetVideoDecTest.cpp
@@ -671,8 +671,8 @@ android::DescribeColorFormatParams::DescribeColorFormatParams(
     bUsingNativeBuffers = params.bUsingNativeBuffers;
 };
 
-bool isColorFormatFlexibleYUV420(sp<IOmxNode> omxNode,
-                                 OMX_COLOR_FORMATTYPE eColorFormat) {
+bool isColorFormatFlexibleYUV(sp<IOmxNode> omxNode,
+                              OMX_COLOR_FORMATTYPE eColorFormat) {
     android::hardware::media::omx::V1_0::Status status;
     unsigned int index = OMX_IndexMax, index2 = OMX_IndexMax;
     omxNode->getExtensionIndex(
@@ -740,11 +740,7 @@ bool isColorFormatFlexibleYUV420(sp<IOmxNode> omxNode,
     return false;
 }
 
-// get default color format for output port.
-// Recommended Order of Supported Color Formats :
-//   1. most efficient hardware format
-//   2. most efficient flexible YUV format
-//   3. other formats
+// get default color format for output port
 void getDefaultColorFormat(sp<IOmxNode> omxNode, OMX_U32 kPortIndexOutput,
                            PortMode oPortMode,
                            OMX_COLOR_FORMATTYPE* eColorFormat) {
@@ -758,21 +754,13 @@ void getDefaultColorFormat(sp<IOmxNode> omxNode, OMX_U32 kPortIndexOutput,
         if (status != ::android::hardware::media::omx::V1_0::Status::OK) break;
         EXPECT_EQ(portFormat.eCompressionFormat, OMX_VIDEO_CodingUnused);
         if (oPortMode != PortMode::PRESET_BYTE_BUFFER) {
-            // In GraphicBuffermode pick first format in the list as the desired
-            // format
             *eColorFormat = portFormat.eColorFormat;
             break;
         }
-        // FlexibleYUV color format is supported in both graphic and shared mem
-        // mode
-        if (isColorFormatFlexibleYUV420(omxNode, portFormat.eColorFormat)) {
+        if (isColorFormatFlexibleYUV(omxNode, portFormat.eColorFormat)) {
             *eColorFormat = portFormat.eColorFormat;
             break;
         }
-        // Video components must support either OMX_COLOR_FormatYUV420Planar
-        // or OMX_COLOR_FormatYUV420SemiPlanar format in shared memory mode.
-        // Android treats Packed formats identical to the unpacked version as
-        // as all raw video buffers must be packed (nSliceHeight = height)
         if (OMX_COLOR_FormatYUV420SemiPlanar == portFormat.eColorFormat ||
             OMX_COLOR_FormatYUV420Planar == portFormat.eColorFormat ||
             OMX_COLOR_FormatYUV420PackedPlanar == portFormat.eColorFormat ||
@@ -854,102 +842,84 @@ TEST_F(VideoDecHidlTest, DecodeTest) {
         eleInfo >> flags;
         eleInfo >> timestamp;
         Info.push_back({bytesCount, flags, timestamp});
+        if (timestampDevTest && (flags != OMX_BUFFERFLAG_CODECCONFIG))
+            timestampUslist.push_back(timestamp);
         if (maxBytesCount < bytesCount) maxBytesCount = bytesCount;
     }
-    maxBytesCount = ALIGN_POWER_OF_TWO(maxBytesCount, 10);
     eleInfo.close();
 
+    // As the frame sizes are known ahead, use it to configure i/p buffer size
+    maxBytesCount = ALIGN_POWER_OF_TWO(maxBytesCount, 10);
+    status = setPortBufferSize(omxNode, kPortIndexInput, maxBytesCount);
+    ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
+
+    // Change the port modes arbitrarily at the start before finialising on the
+    // desired values.
     PortMode dummyPM[] = {
         PortMode::PRESET_BYTE_BUFFER,    PortMode::PRESET_ANW_BUFFER,
         PortMode::PRESET_SECURE_BUFFER,  PortMode::DYNAMIC_ANW_BUFFER,
         PortMode::DYNAMIC_NATIVE_HANDLE,
     };
-    PortMode pmArray[] = {PortMode::PRESET_BYTE_BUFFER,
-                          PortMode::DYNAMIC_ANW_BUFFER,
-                          PortMode::PRESET_ANW_BUFFER};
-
-    for (size_t j = 0; j < sizeof(pmArray) / sizeof(pmArray[0]); j++) {
-        // Change the port modes arbitrarily at the start before finialising
-        // on the desired values.
-        for (size_t k = 0; k < sizeof(dummyPM) / sizeof(dummyPM[0]); k++) {
-            // ports may or may not support these modes. These are not the final
-            // values. This init is done to test if causes any problems.
-            status = omxNode->setPortMode(kPortIndexInput, dummyPM[k]);
-            status = omxNode->setPortMode(kPortIndexOutput, dummyPM[k]);
-        }
-        // set port mode
-        portMode[0] = PortMode::PRESET_BYTE_BUFFER;
-        portMode[1] = pmArray[j];
-        status = omxNode->setPortMode(kPortIndexInput, portMode[0]);
-        ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
-        status = omxNode->setPortMode(kPortIndexOutput, portMode[1]);
-        if (status != ::android::hardware::media::omx::V1_0::Status::OK) {
-            continue;
-        }
+    for (size_t k = 0; k < sizeof(dummyPM) / sizeof(dummyPM[0]); k++) {
+        // ports may or may not support these modes. These are not the final
+        // values. This init is done to test if causes any problems.
+        status = omxNode->setPortMode(kPortIndexInput, dummyPM[k]);
+        status = omxNode->setPortMode(kPortIndexOutput, dummyPM[k]);
+    }
 
-        // The input width and height information is necessary for the component
-        // to configure the size of the input buffer. But this is not available.
-        // As the frame sizes are known ahead, use it to configure i/p buffer
-        // size.
-        status = setPortBufferSize(omxNode, kPortIndexInput, maxBytesCount);
+    // set port mode
+    portMode[0] = PortMode::PRESET_BYTE_BUFFER;
+    portMode[1] = PortMode::DYNAMIC_ANW_BUFFER;
+    status = omxNode->setPortMode(kPortIndexInput, portMode[0]);
+    ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
+    status = omxNode->setPortMode(kPortIndexOutput, portMode[1]);
+    if (status != ::android::hardware::media::omx::V1_0::Status::OK) {
+        portMode[1] = PortMode::PRESET_BYTE_BUFFER;
+        status = omxNode->setPortMode(kPortIndexOutput, portMode[1]);
         ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
-
-        // prepare list of input timestamps
-        for (size_t frameID = 0; frameID < Info.size(); frameID++) {
-            if (timestampDevTest &&
-                (Info[frameID].flags != OMX_BUFFERFLAG_CODECCONFIG))
-                timestampUslist.push_back(Info[frameID].timestamp);
-        }
-
-        // set Port Params
-        uint32_t nFrameWidth, nFrameHeight, xFramerate;
-        getInputChannelInfo(omxNode, kPortIndexInput, &nFrameWidth,
-                            &nFrameHeight, &xFramerate);
-        // get default color format
-        OMX_COLOR_FORMATTYPE eColorFormat = OMX_COLOR_FormatUnused;
-        getDefaultColorFormat(omxNode, kPortIndexOutput, portMode[1],
-                              &eColorFormat);
-        ASSERT_NE(eColorFormat, OMX_COLOR_FormatUnused);
-        status = setVideoPortFormat(omxNode, kPortIndexOutput,
-                                    OMX_VIDEO_CodingUnused, eColorFormat,
-                                    xFramerate);
-        EXPECT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
-        setDefaultPortParam(omxNode, kPortIndexOutput, OMX_VIDEO_CodingUnused,
-                            eColorFormat, nFrameWidth, nFrameHeight, 0,
-                            xFramerate);
-
-        android::Vector<BufferInfo> iBuffer, oBuffer;
-
-        // set state to idle
-        changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,
-                                kPortIndexInput, kPortIndexOutput, portMode,
-                                true);
-        // set state to executing
-        changeStateIdletoExecute(omxNode, observer);
-
-        // Port Reconfiguration
-        eleStream.open(mURL, std::ifstream::binary);
-        ASSERT_EQ(eleStream.is_open(), true);
-        decodeNFrames(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
-                      kPortIndexOutput, eleStream, &Info, 0, (int)Info.size(),
-                      portMode[1]);
-        eleStream.close();
-        waitOnInputConsumption(omxNode, observer, &iBuffer, &oBuffer,
-                               kPortIndexInput, kPortIndexOutput, portMode[1]);
-        testEOS(omxNode, observer, &iBuffer, &oBuffer, false, eosFlag, portMode,
-                portReconfiguration, kPortIndexInput, kPortIndexOutput,
-                nullptr);
-        if (timestampDevTest) EXPECT_EQ(timestampUslist.empty(), true);
-        eosFlag = false;
-        timestampUslist.clear();
-        framesReceived = 0;
-        timestampUs = 0;
-        // set state to idle
-        changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
-        // set state to loaded
-        changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
-                                kPortIndexInput, kPortIndexOutput);
     }
+
+    // set Port Params
+    uint32_t nFrameWidth, nFrameHeight, xFramerate;
+    getInputChannelInfo(omxNode, kPortIndexInput, &nFrameWidth, &nFrameHeight,
+                        &xFramerate);
+    // get default color format
+    OMX_COLOR_FORMATTYPE eColorFormat = OMX_COLOR_FormatUnused;
+    getDefaultColorFormat(omxNode, kPortIndexOutput, portMode[1],
+                          &eColorFormat);
+    ASSERT_NE(eColorFormat, OMX_COLOR_FormatUnused);
+    status =
+        setVideoPortFormat(omxNode, kPortIndexOutput, OMX_VIDEO_CodingUnused,
+                           eColorFormat, xFramerate);
+    EXPECT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
+    setDefaultPortParam(omxNode, kPortIndexOutput, OMX_VIDEO_CodingUnused,
+                        eColorFormat, nFrameWidth, nFrameHeight, 0, xFramerate);
+
+    android::Vector<BufferInfo> iBuffer, oBuffer;
+
+    // set state to idle
+    changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,
+                            kPortIndexInput, kPortIndexOutput, portMode, true);
+    // set state to executing
+    changeStateIdletoExecute(omxNode, observer);
+
+    // Port Reconfiguration
+    eleStream.open(mURL, std::ifstream::binary);
+    ASSERT_EQ(eleStream.is_open(), true);
+    decodeNFrames(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
+                  kPortIndexOutput, eleStream, &Info, 0, (int)Info.size(),
+                  portMode[1]);
+    eleStream.close();
+    waitOnInputConsumption(omxNode, observer, &iBuffer, &oBuffer,
+                           kPortIndexInput, kPortIndexOutput, portMode[1]);
+    testEOS(omxNode, observer, &iBuffer, &oBuffer, false, eosFlag, portMode,
+            portReconfiguration, kPortIndexInput, kPortIndexOutput, nullptr);
+    if (timestampDevTest) EXPECT_EQ(timestampUslist.empty(), true);
+    // set state to idle
+    changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
+    // set state to executing
+    changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
+                            kPortIndexInput, kPortIndexOutput);
 }
 
 // Test for adaptive playback support
@@ -971,153 +941,127 @@ TEST_F(VideoDecHidlTest, AdaptivePlaybackTest) {
         kPortIndexOutput = kPortIndexInput + 1;
     }
 
-    bool apbSupport = false;
-    PortMode pmArray[] = {
-        PortMode::PRESET_BYTE_BUFFER, PortMode::DYNAMIC_ANW_BUFFER,
-        PortMode::PRESET_ANW_BUFFER,
-    };
-    for (size_t j = 0; j < sizeof(pmArray) / sizeof(pmArray[0]); j++) {
-        // set port mode
-        portMode[0] = PortMode::PRESET_BYTE_BUFFER;
-        portMode[1] = pmArray[j];
-        status = omxNode->setPortMode(kPortIndexInput, portMode[0]);
-        ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
+    // set port mode
+    portMode[0] = PortMode::PRESET_BYTE_BUFFER;
+    portMode[1] = PortMode::DYNAMIC_ANW_BUFFER;
+    status = omxNode->setPortMode(kPortIndexInput, portMode[0]);
+    ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
+    status = omxNode->setPortMode(kPortIndexOutput, portMode[1]);
+    if (status != ::android::hardware::media::omx::V1_0::Status::OK) {
+        portMode[1] = PortMode::PRESET_BYTE_BUFFER;
         status = omxNode->setPortMode(kPortIndexOutput, portMode[1]);
-        if (status != ::android::hardware::media::omx::V1_0::Status::OK) {
-            continue;
-        }
+        ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
+    }
 
-        // prepare for adaptive playback
-        uint32_t adaptiveMaxWidth = 320;
-        uint32_t adaptiveMaxHeight = 240;
-        status = omxNode->prepareForAdaptivePlayback(
-            kPortIndexOutput, true, adaptiveMaxWidth, adaptiveMaxHeight);
-        if (strncmp(gEnv->getComponent().c_str(), "OMX.google.", 11) == 0) {
-            // SoftOMX Decoders donot support graphic buffer modes. So for them
-            // support for adaptive play back is mandatory in Byte Buffer mode
-            ASSERT_EQ(status,
-                      ::android::hardware::media::omx::V1_0::Status::OK);
-        } else {
-            // Adaptive playback not supported
-            if (status != ::android::hardware::media::omx::V1_0::Status::OK)
-                continue;
-            // for vendor codecs, support for adaptive play back is optional
-            // in byte buffer mode. But they must be supported in atleast one
-            // graphic buffer mode
-            if (portMode[1] == PortMode::PRESET_BYTE_BUFFER ||
-                apbSupport == true)
-                continue;
-            else
-                apbSupport = true;
+    // prepare for adaptive playback
+    uint32_t adaptiveMaxWidth = 320;
+    uint32_t adaptiveMaxHeight = 240;
+    status = omxNode->prepareForAdaptivePlayback(
+        kPortIndexOutput, true, adaptiveMaxWidth, adaptiveMaxHeight);
+    if (strncmp(gEnv->getComponent().c_str(), "OMX.google.", 11) == 0) {
+        // SoftOMX Decoders donot support graphic buffer modes. So for them
+        // support for adaptive play back is mandatory in Byte Buffer mode
+        ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
+    } else {
+        // for vendor codecs, support for adaptive play back is optional
+        // in byte buffer mode.
+        if (portMode[1] == PortMode::PRESET_BYTE_BUFFER) return;
+        if (status != ::android::hardware::media::omx::V1_0::Status::OK) return;
+    }
+
+    // TODO: Handle this better !!!
+    // Without the knowledge of the maximum resolution of the frame to be
+    // decoded it is not possible to choose the size of the input buffer.
+    // The value below is based on the info. files of clips in res folder.
+    status = setPortBufferSize(omxNode, kPortIndexInput, 482304);
+    ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
+
+    // set Port Params
+    uint32_t nFrameWidth, nFrameHeight, xFramerate;
+    getInputChannelInfo(omxNode, kPortIndexInput, &nFrameWidth, &nFrameHeight,
+                        &xFramerate);
+    // get default color format
+    OMX_COLOR_FORMATTYPE eColorFormat = OMX_COLOR_FormatUnused;
+    getDefaultColorFormat(omxNode, kPortIndexOutput, portMode[1],
+                          &eColorFormat);
+    ASSERT_NE(eColorFormat, OMX_COLOR_FormatUnused);
+    status =
+        setVideoPortFormat(omxNode, kPortIndexOutput, OMX_VIDEO_CodingUnused,
+                           eColorFormat, xFramerate);
+    EXPECT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
+    setDefaultPortParam(omxNode, kPortIndexOutput, OMX_VIDEO_CodingUnused,
+                        eColorFormat, nFrameWidth, nFrameHeight, 0, xFramerate);
+
+    android::Vector<BufferInfo> iBuffer, oBuffer;
+
+    // set state to idle
+    changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,
+                            kPortIndexInput, kPortIndexOutput, portMode, true);
+    // set state to executing
+    changeStateIdletoExecute(omxNode, observer);
+
+    timestampDevTest = true;
+    uint32_t timestampOffset = 0;
+    for (uint32_t i = 0; i < STREAM_COUNT * 2; i++) {
+        std::ifstream eleStream, eleInfo;
+        char mURL[512], info[512];
+        android::Vector<FrameData> Info;
+        strcpy(mURL, gEnv->getRes().c_str());
+        strcpy(info, gEnv->getRes().c_str());
+        GetURLForComponent(compName, mURL, info, i % STREAM_COUNT);
+        eleInfo.open(info);
+        ASSERT_EQ(eleInfo.is_open(), true);
+        int bytesCount = 0;
+        uint32_t flags = 0;
+        uint32_t timestamp = 0;
+        uint32_t timestampMax = 0;
+        while (1) {
+            if (!(eleInfo >> bytesCount)) break;
+            eleInfo >> flags;
+            eleInfo >> timestamp;
+            timestamp += timestampOffset;
+            Info.push_back({bytesCount, flags, timestamp});
+            if (timestampDevTest && (flags != OMX_BUFFERFLAG_CODECCONFIG))
+                timestampUslist.push_back(timestamp);
+            if (timestampMax < timestamp) timestampMax = timestamp;
         }
+        timestampOffset = timestampMax;
+        eleInfo.close();
 
-        // TODO: Handle this better !!!
-        // Without the knowledge of the maximum resolution of the frame to be
-        // decoded it is not possible to choose the size of the input buffer.
-        // The value below is based on the info. files of clips in res folder.
-        status = setPortBufferSize(omxNode, kPortIndexInput, 482304);
-        ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
+        // Port Reconfiguration
+        eleStream.open(mURL, std::ifstream::binary);
+        ASSERT_EQ(eleStream.is_open(), true);
+        decodeNFrames(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
+                      kPortIndexOutput, eleStream, &Info, 0, (int)Info.size(),
+                      portMode[1], false);
+        eleStream.close();
 
-        // set Port Params
-        uint32_t nFrameWidth, nFrameHeight, xFramerate;
         getInputChannelInfo(omxNode, kPortIndexInput, &nFrameWidth,
                             &nFrameHeight, &xFramerate);
-        // get default color format
-        OMX_COLOR_FORMATTYPE eColorFormat = OMX_COLOR_FormatUnused;
-        getDefaultColorFormat(omxNode, kPortIndexOutput, portMode[1],
-                              &eColorFormat);
-        ASSERT_NE(eColorFormat, OMX_COLOR_FormatUnused);
-        status = setVideoPortFormat(omxNode, kPortIndexOutput,
-                                    OMX_VIDEO_CodingUnused, eColorFormat,
-                                    xFramerate);
-        EXPECT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
-        setDefaultPortParam(omxNode, kPortIndexOutput, OMX_VIDEO_CodingUnused,
-                            eColorFormat, nFrameWidth, nFrameHeight, 0,
-                            xFramerate);
-
-        android::Vector<BufferInfo> iBuffer, oBuffer;
-
-        // set state to idle
-        changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,
-                                kPortIndexInput, kPortIndexOutput, portMode,
-                                true);
-        // set state to executing
-        changeStateIdletoExecute(omxNode, observer);
-
-        timestampDevTest = true;
-        uint32_t timestampOffset = 0;
-        for (uint32_t i = 0; i < STREAM_COUNT * 2; i++) {
-            std::ifstream eleStream, eleInfo;
-            char mURL[512], info[512];
-            android::Vector<FrameData> Info;
-            strcpy(mURL, gEnv->getRes().c_str());
-            strcpy(info, gEnv->getRes().c_str());
-            GetURLForComponent(compName, mURL, info, i % STREAM_COUNT);
-            eleInfo.open(info);
-            ASSERT_EQ(eleInfo.is_open(), true);
-            int bytesCount = 0;
-            uint32_t flags = 0;
-            uint32_t timestamp = 0;
-            uint32_t timestampMax = 0;
-            while (1) {
-                if (!(eleInfo >> bytesCount)) break;
-                eleInfo >> flags;
-                eleInfo >> timestamp;
-                timestamp += timestampOffset;
-                Info.push_back({bytesCount, flags, timestamp});
-                if (timestampDevTest && (flags != OMX_BUFFERFLAG_CODECCONFIG))
-                    timestampUslist.push_back(timestamp);
-                if (timestampMax < timestamp) timestampMax = timestamp;
-            }
-            timestampOffset = timestampMax;
-            eleInfo.close();
-
-            // Port Reconfiguration
-            eleStream.open(mURL, std::ifstream::binary);
-            ASSERT_EQ(eleStream.is_open(), true);
-            decodeNFrames(omxNode, observer, &iBuffer, &oBuffer,
-                          kPortIndexInput, kPortIndexOutput, eleStream, &Info,
-                          0, (int)Info.size(), portMode[1], false);
-            eleStream.close();
-
-            getInputChannelInfo(omxNode, kPortIndexInput, &nFrameWidth,
-                                &nFrameHeight, &xFramerate);
-            if ((nFrameWidth > adaptiveMaxWidth) ||
-                (nFrameHeight > adaptiveMaxHeight)) {
-                if (nFrameWidth > adaptiveMaxWidth)
-                    adaptiveMaxWidth = nFrameWidth;
-                if (nFrameHeight > adaptiveMaxHeight)
-                    adaptiveMaxHeight = nFrameHeight;
-                EXPECT_TRUE(portSettingsChange);
-            } else {
-                // In DynamicANW Buffer mode, it is ok to do a complete
-                // reconfiguration even if a partial reconfiguration is
-                // sufficient.
-                if (portMode[1] != PortMode::DYNAMIC_ANW_BUFFER)
-                    EXPECT_FALSE(portSettingsChange);
-            }
-            portSettingsChange = false;
+        if ((nFrameWidth > adaptiveMaxWidth) ||
+            (nFrameHeight > adaptiveMaxHeight)) {
+            if (nFrameWidth > adaptiveMaxWidth) adaptiveMaxWidth = nFrameWidth;
+            if (nFrameHeight > adaptiveMaxHeight)
+                adaptiveMaxHeight = nFrameHeight;
+            EXPECT_TRUE(portSettingsChange);
+        } else {
+            // In DynamicANW Buffer mode, its ok to do a complete
+            // reconfiguration even if a partial reconfiguration is sufficient.
+            if (portMode[1] != PortMode::DYNAMIC_ANW_BUFFER)
+                EXPECT_FALSE(portSettingsChange);
         }
-        waitOnInputConsumption(omxNode, observer, &iBuffer, &oBuffer,
-                               kPortIndexInput, kPortIndexOutput, portMode[1]);
-        testEOS(omxNode, observer, &iBuffer, &oBuffer, true, eosFlag, portMode,
-                portReconfiguration, kPortIndexInput, kPortIndexOutput,
-                nullptr);
-        if (timestampDevTest) EXPECT_EQ(timestampUslist.empty(), true);
-        eosFlag = false;
-        timestampUslist.clear();
-        framesReceived = 0;
-        timestampUs = 0;
-        // set state to idle
-        changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
-        // set state to loaded
-        changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
-                                kPortIndexInput, kPortIndexOutput);
+        portSettingsChange = false;
     }
-    // For Vendor components ensure apb is supported in atleast one graphic
-    // buffer mode
-    if (strncmp(gEnv->getComponent().c_str(), "OMX.google.", 11) != 0)
-        EXPECT_TRUE(apbSupport);
+    waitOnInputConsumption(omxNode, observer, &iBuffer, &oBuffer,
+                           kPortIndexInput, kPortIndexOutput, portMode[1]);
+    testEOS(omxNode, observer, &iBuffer, &oBuffer, true, eosFlag, portMode,
+            portReconfiguration, kPortIndexInput, kPortIndexOutput, nullptr);
+    if (timestampDevTest) EXPECT_EQ(timestampUslist.empty(), true);
+    // set state to idle
+    changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
+    // set state to executing
+    changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
+                            kPortIndexInput, kPortIndexOutput);
 }
 
 // end of sequence test
@@ -1136,62 +1080,50 @@ TEST_F(VideoDecHidlTest, EOSTest_M) {
         kPortIndexOutput = kPortIndexInput + 1;
     }
 
-    PortMode pmArray[] = {PortMode::PRESET_BYTE_BUFFER,
-                          PortMode::DYNAMIC_ANW_BUFFER,
-                          PortMode::PRESET_ANW_BUFFER};
-    for (size_t j = 0; j < sizeof(pmArray) / sizeof(pmArray[0]); j++) {
-        // set port mode
-        portMode[0] = PortMode::PRESET_BYTE_BUFFER;
-        portMode[1] = pmArray[j];
-        status = omxNode->setPortMode(kPortIndexInput, portMode[0]);
-        ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
-        status = omxNode->setPortMode(kPortIndexOutput, portMode[1]);
-        if (status != ::android::hardware::media::omx::V1_0::Status::OK) {
-            continue;
-        }
+    // set port mode
+    status = omxNode->setPortMode(kPortIndexInput, portMode[0]);
+    ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
+    status = omxNode->setPortMode(kPortIndexOutput, portMode[1]);
+    ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
 
-        // set Port Params
-        uint32_t nFrameWidth, nFrameHeight, xFramerate;
-        getInputChannelInfo(omxNode, kPortIndexInput, &nFrameWidth,
-                            &nFrameHeight, &xFramerate);
-        // get default color format
-        OMX_COLOR_FORMATTYPE eColorFormat = OMX_COLOR_FormatUnused;
-        getDefaultColorFormat(omxNode, kPortIndexOutput, portMode[1],
-                              &eColorFormat);
-        ASSERT_NE(eColorFormat, OMX_COLOR_FormatUnused);
-        status = setVideoPortFormat(omxNode, kPortIndexOutput,
-                                    OMX_VIDEO_CodingUnused, eColorFormat,
-                                    xFramerate);
-        EXPECT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
-        setDefaultPortParam(omxNode, kPortIndexOutput, OMX_VIDEO_CodingUnused,
-                            eColorFormat, nFrameWidth, nFrameHeight, 0,
-                            xFramerate);
-
-        android::Vector<BufferInfo> iBuffer, oBuffer;
-
-        // set state to idle
-        changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,
-                                kPortIndexInput, kPortIndexOutput, portMode,
-                                true);
-        // set state to executing
-        changeStateIdletoExecute(omxNode, observer);
-        // request EOS at the start
-        testEOS(omxNode, observer, &iBuffer, &oBuffer, true, eosFlag, portMode,
-                portReconfiguration, kPortIndexInput, kPortIndexOutput,
-                nullptr);
-        flushPorts(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
-                   kPortIndexOutput);
-        EXPECT_GE(framesReceived, 0U);
-        eosFlag = false;
-        timestampUslist.clear();
-        framesReceived = 0;
-        timestampUs = 0;
-        // set state to idle
-        changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
-        // set state to loaded
-        changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
-                                kPortIndexInput, kPortIndexOutput);
-    }
+    // set Port Params
+    uint32_t nFrameWidth, nFrameHeight, xFramerate;
+    getInputChannelInfo(omxNode, kPortIndexInput, &nFrameWidth, &nFrameHeight,
+                        &xFramerate);
+    // get default color format
+    OMX_COLOR_FORMATTYPE eColorFormat = OMX_COLOR_FormatUnused;
+    getDefaultColorFormat(omxNode, kPortIndexOutput, portMode[1],
+                          &eColorFormat);
+    ASSERT_NE(eColorFormat, OMX_COLOR_FormatUnused);
+    status =
+        setVideoPortFormat(omxNode, kPortIndexOutput, OMX_VIDEO_CodingUnused,
+                           eColorFormat, xFramerate);
+    EXPECT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
+    setDefaultPortParam(omxNode, kPortIndexOutput, OMX_VIDEO_CodingUnused,
+                        eColorFormat, nFrameWidth, nFrameHeight, 0, xFramerate);
+
+    android::Vector<BufferInfo> iBuffer, oBuffer;
+
+    // set state to idle
+    changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,
+                            kPortIndexInput, kPortIndexOutput, portMode, true);
+    // set state to executing
+    changeStateIdletoExecute(omxNode, observer);
+
+    // request EOS at the start
+    testEOS(omxNode, observer, &iBuffer, &oBuffer, true, eosFlag, portMode,
+            portReconfiguration, kPortIndexInput, kPortIndexOutput, nullptr);
+    flushPorts(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
+               kPortIndexOutput);
+    EXPECT_GE(framesReceived, 0U);
+    framesReceived = 0;
+    timestampUs = 0;
+
+    // set state to idle
+    changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
+    // set state to executing
+    changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
+                            kPortIndexInput, kPortIndexOutput);
 }
 
 // end of sequence test
@@ -1229,101 +1161,82 @@ TEST_F(VideoDecHidlTest, ThumbnailTest) {
         Info.push_back({bytesCount, flags, timestamp});
         if (maxBytesCount < bytesCount) maxBytesCount = bytesCount;
     }
-    maxBytesCount = ALIGN_POWER_OF_TWO(maxBytesCount, 10);
     eleInfo.close();
 
-    PortMode pmArray[] = {PortMode::PRESET_BYTE_BUFFER,
-                          PortMode::DYNAMIC_ANW_BUFFER,
-                          PortMode::PRESET_ANW_BUFFER};
-    for (size_t j = 0; j < sizeof(pmArray) / sizeof(pmArray[0]); j++) {
-        // set port mode
-        portMode[0] = PortMode::PRESET_BYTE_BUFFER;
-        portMode[1] = pmArray[j];
-        status = omxNode->setPortMode(kPortIndexInput, portMode[0]);
-        ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
-        status = omxNode->setPortMode(kPortIndexOutput, portMode[1]);
-        if (status != ::android::hardware::media::omx::V1_0::Status::OK) {
-            continue;
-        }
-
-        // As the frame sizes are known ahead, use it to configure i/p buffer
-        // size
-        status = setPortBufferSize(omxNode, kPortIndexInput, maxBytesCount);
-        ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
-
-        // set Port Params
-        uint32_t nFrameWidth, nFrameHeight, xFramerate;
-        getInputChannelInfo(omxNode, kPortIndexInput, &nFrameWidth,
-                            &nFrameHeight, &xFramerate);
-        // get default color format
-        OMX_COLOR_FORMATTYPE eColorFormat = OMX_COLOR_FormatUnused;
-        getDefaultColorFormat(omxNode, kPortIndexOutput, portMode[1],
-                              &eColorFormat);
-        ASSERT_NE(eColorFormat, OMX_COLOR_FormatUnused);
-        status = setVideoPortFormat(omxNode, kPortIndexOutput,
-                                    OMX_VIDEO_CodingUnused, eColorFormat,
-                                    xFramerate);
-        EXPECT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
-        setDefaultPortParam(omxNode, kPortIndexOutput, OMX_VIDEO_CodingUnused,
-                            eColorFormat, nFrameWidth, nFrameHeight, 0,
-                            xFramerate);
-
-        android::Vector<BufferInfo> iBuffer, oBuffer;
-
-        // set state to idle
-        changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,
-                                kPortIndexInput, kPortIndexOutput, portMode,
-                                true);
-        // set state to executing
-        changeStateIdletoExecute(omxNode, observer);
-
-        // request EOS for thumbnail
-        size_t i = 0;
-        while (!(Info[i].flags & OMX_BUFFERFLAG_SYNCFRAME)) i++;
-        eleStream.open(mURL, std::ifstream::binary);
-        ASSERT_EQ(eleStream.is_open(), true);
-        decodeNFrames(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
-                      kPortIndexOutput, eleStream, &Info, 0, i + 1,
-                      portMode[1]);
-        eleStream.close();
-        waitOnInputConsumption(omxNode, observer, &iBuffer, &oBuffer,
-                               kPortIndexInput, kPortIndexOutput, portMode[1]);
-        testEOS(omxNode, observer, &iBuffer, &oBuffer, false, eosFlag, portMode,
-                portReconfiguration, kPortIndexInput, kPortIndexOutput,
-                nullptr);
-        flushPorts(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
-                   kPortIndexOutput);
-        EXPECT_GE(framesReceived, 1U);
-        eosFlag = false;
-        timestampUslist.clear();
-        framesReceived = 0;
-        timestampUs = 0;
+    // As the frame sizes are known ahead, use it to configure i/p buffer size
+    maxBytesCount = ALIGN_POWER_OF_TWO(maxBytesCount, 10);
+    status = setPortBufferSize(omxNode, kPortIndexInput, maxBytesCount);
+    ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
 
-        eleStream.open(mURL, std::ifstream::binary);
-        ASSERT_EQ(eleStream.is_open(), true);
-        decodeNFrames(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
-                      kPortIndexOutput, eleStream, &Info, 0, i + 1, portMode[1],
-                      false);
-        eleStream.close();
-        waitOnInputConsumption(omxNode, observer, &iBuffer, &oBuffer,
-                               kPortIndexInput, kPortIndexOutput, portMode[1]);
-        testEOS(omxNode, observer, &iBuffer, &oBuffer, true, eosFlag, portMode,
-                portReconfiguration, kPortIndexInput, kPortIndexOutput,
-                nullptr);
-        flushPorts(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
-                   kPortIndexOutput);
-        EXPECT_GE(framesReceived, 1U);
-        eosFlag = false;
-        timestampUslist.clear();
-        framesReceived = 0;
-        timestampUs = 0;
+    // set port mode
+    status = omxNode->setPortMode(kPortIndexInput, portMode[0]);
+    ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
+    status = omxNode->setPortMode(kPortIndexOutput, portMode[1]);
+    ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
 
-        // set state to idle
-        changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
-        // set state to loaded
-        changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
-                                kPortIndexInput, kPortIndexOutput);
-    }
+    // set Port Params
+    uint32_t nFrameWidth, nFrameHeight, xFramerate;
+    getInputChannelInfo(omxNode, kPortIndexInput, &nFrameWidth, &nFrameHeight,
+                        &xFramerate);
+    // get default color format
+    OMX_COLOR_FORMATTYPE eColorFormat = OMX_COLOR_FormatUnused;
+    getDefaultColorFormat(omxNode, kPortIndexOutput, portMode[1],
+                          &eColorFormat);
+    ASSERT_NE(eColorFormat, OMX_COLOR_FormatUnused);
+    status =
+        setVideoPortFormat(omxNode, kPortIndexOutput, OMX_VIDEO_CodingUnused,
+                           eColorFormat, xFramerate);
+    EXPECT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
+    setDefaultPortParam(omxNode, kPortIndexOutput, OMX_VIDEO_CodingUnused,
+                        eColorFormat, nFrameWidth, nFrameHeight, 0, xFramerate);
+
+    android::Vector<BufferInfo> iBuffer, oBuffer;
+
+    // set state to idle
+    changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,
+                            kPortIndexInput, kPortIndexOutput, portMode, true);
+    // set state to executing
+    changeStateIdletoExecute(omxNode, observer);
+
+    // request EOS for thumbnail
+    size_t i = 0;
+    while (!(Info[i].flags & OMX_BUFFERFLAG_SYNCFRAME)) i++;
+    eleStream.open(mURL, std::ifstream::binary);
+    ASSERT_EQ(eleStream.is_open(), true);
+    decodeNFrames(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
+                  kPortIndexOutput, eleStream, &Info, 0, i + 1, portMode[1]);
+    eleStream.close();
+    waitOnInputConsumption(omxNode, observer, &iBuffer, &oBuffer,
+                           kPortIndexInput, kPortIndexOutput, portMode[1]);
+    testEOS(omxNode, observer, &iBuffer, &oBuffer, false, eosFlag, portMode,
+            portReconfiguration, kPortIndexInput, kPortIndexOutput, nullptr);
+    flushPorts(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
+               kPortIndexOutput);
+    EXPECT_GE(framesReceived, 1U);
+    framesReceived = 0;
+    timestampUs = 0;
+
+    eleStream.open(mURL, std::ifstream::binary);
+    ASSERT_EQ(eleStream.is_open(), true);
+    decodeNFrames(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
+                  kPortIndexOutput, eleStream, &Info, 0, i + 1, portMode[1],
+                  false);
+    eleStream.close();
+    waitOnInputConsumption(omxNode, observer, &iBuffer, &oBuffer,
+                           kPortIndexInput, kPortIndexOutput, portMode[1]);
+    testEOS(omxNode, observer, &iBuffer, &oBuffer, true, eosFlag, portMode,
+            portReconfiguration, kPortIndexInput, kPortIndexOutput, nullptr);
+    flushPorts(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
+               kPortIndexOutput);
+    EXPECT_GE(framesReceived, 1U);
+    framesReceived = 0;
+    timestampUs = 0;
+
+    // set state to idle
+    changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
+    // set state to executing
+    changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
+                            kPortIndexInput, kPortIndexOutput);
 }
 
 // end of sequence test
@@ -1361,79 +1274,70 @@ TEST_F(VideoDecHidlTest, SimpleEOSTest) {
         Info.push_back({bytesCount, flags, timestamp});
         if (maxBytesCount < bytesCount) maxBytesCount = bytesCount;
     }
-    maxBytesCount = ALIGN_POWER_OF_TWO(maxBytesCount, 10);
     eleInfo.close();
 
-    PortMode pmArray[] = {PortMode::PRESET_BYTE_BUFFER,
-                          PortMode::DYNAMIC_ANW_BUFFER,
-                          PortMode::PRESET_ANW_BUFFER};
-    for (size_t j = 0; j < sizeof(pmArray) / sizeof(pmArray[0]); j++) {
-        // set port mode
-        portMode[0] = PortMode::PRESET_BYTE_BUFFER;
-        portMode[1] = pmArray[j];
-        status = omxNode->setPortMode(kPortIndexInput, portMode[0]);
-        ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
-        status = omxNode->setPortMode(kPortIndexOutput, portMode[1]);
-        if (status != ::android::hardware::media::omx::V1_0::Status::OK) {
-            continue;
-        }
+    // As the frame sizes are known ahead, use it to configure i/p buffer size
+    maxBytesCount = ALIGN_POWER_OF_TWO(maxBytesCount, 10);
+    status = setPortBufferSize(omxNode, kPortIndexInput, maxBytesCount);
+    ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
 
-        // As the frame sizes are known ahead, use it to configure i/p buffer
-        // size
-        status = setPortBufferSize(omxNode, kPortIndexInput, maxBytesCount);
+    // set port mode
+    portMode[0] = PortMode::PRESET_BYTE_BUFFER;
+    portMode[1] = PortMode::PRESET_ANW_BUFFER;
+    status = omxNode->setPortMode(kPortIndexInput, portMode[0]);
+    ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
+    status = omxNode->setPortMode(kPortIndexOutput, portMode[1]);
+    if (status != ::android::hardware::media::omx::V1_0::Status::OK) {
+        portMode[1] = PortMode::PRESET_BYTE_BUFFER;
+        status = omxNode->setPortMode(kPortIndexOutput, portMode[1]);
         ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
-
-        // set Port Params
-        uint32_t nFrameWidth, nFrameHeight, xFramerate;
-        getInputChannelInfo(omxNode, kPortIndexInput, &nFrameWidth,
-                            &nFrameHeight, &xFramerate);
-        // get default color format
-        OMX_COLOR_FORMATTYPE eColorFormat = OMX_COLOR_FormatUnused;
-        getDefaultColorFormat(omxNode, kPortIndexOutput, portMode[1],
-                              &eColorFormat);
-        ASSERT_NE(eColorFormat, OMX_COLOR_FormatUnused);
-        status = setVideoPortFormat(omxNode, kPortIndexOutput,
-                                    OMX_VIDEO_CodingUnused, eColorFormat,
-                                    xFramerate);
-        EXPECT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
-        setDefaultPortParam(omxNode, kPortIndexOutput, OMX_VIDEO_CodingUnused,
-                            eColorFormat, nFrameWidth, nFrameHeight, 0,
-                            xFramerate);
-
-        android::Vector<BufferInfo> iBuffer, oBuffer;
-
-        // set state to idle
-        changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,
-                                kPortIndexInput, kPortIndexOutput, portMode,
-                                true);
-        // set state to executing
-        changeStateIdletoExecute(omxNode, observer);
-
-        // request EOS at the end
-        eleStream.open(mURL, std::ifstream::binary);
-        ASSERT_EQ(eleStream.is_open(), true);
-        decodeNFrames(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
-                      kPortIndexOutput, eleStream, &Info, 0, (int)Info.size(),
-                      portMode[1], false);
-        eleStream.close();
-        waitOnInputConsumption(omxNode, observer, &iBuffer, &oBuffer,
-                               kPortIndexInput, kPortIndexOutput, portMode[1]);
-        testEOS(omxNode, observer, &iBuffer, &oBuffer, true, eosFlag, portMode,
-                portReconfiguration, kPortIndexInput, kPortIndexOutput,
-                nullptr);
-        flushPorts(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
-                   kPortIndexOutput);
-        eosFlag = false;
-        timestampUslist.clear();
-        framesReceived = 0;
-        timestampUs = 0;
-
-        // set state to idle
-        changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
-        // set state to loaded
-        changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
-                                kPortIndexInput, kPortIndexOutput);
     }
+
+    // set Port Params
+    uint32_t nFrameWidth, nFrameHeight, xFramerate;
+    getInputChannelInfo(omxNode, kPortIndexInput, &nFrameWidth, &nFrameHeight,
+                        &xFramerate);
+    // get default color format
+    OMX_COLOR_FORMATTYPE eColorFormat = OMX_COLOR_FormatUnused;
+    getDefaultColorFormat(omxNode, kPortIndexOutput, portMode[1],
+                          &eColorFormat);
+    ASSERT_NE(eColorFormat, OMX_COLOR_FormatUnused);
+    status =
+        setVideoPortFormat(omxNode, kPortIndexOutput, OMX_VIDEO_CodingUnused,
+                           eColorFormat, xFramerate);
+    EXPECT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
+    setDefaultPortParam(omxNode, kPortIndexOutput, OMX_VIDEO_CodingUnused,
+                        eColorFormat, nFrameWidth, nFrameHeight, 0, xFramerate);
+
+    android::Vector<BufferInfo> iBuffer, oBuffer;
+
+    // set state to idle
+    changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,
+                            kPortIndexInput, kPortIndexOutput, portMode, true);
+    // set state to executing
+    changeStateIdletoExecute(omxNode, observer);
+
+    // request EOS at the end
+    eleStream.open(mURL, std::ifstream::binary);
+    ASSERT_EQ(eleStream.is_open(), true);
+    decodeNFrames(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
+                  kPortIndexOutput, eleStream, &Info, 0, (int)Info.size(),
+                  portMode[1], false);
+    eleStream.close();
+    waitOnInputConsumption(omxNode, observer, &iBuffer, &oBuffer,
+                           kPortIndexInput, kPortIndexOutput, portMode[1]);
+    testEOS(omxNode, observer, &iBuffer, &oBuffer, true, eosFlag, portMode,
+            portReconfiguration, kPortIndexInput, kPortIndexOutput, nullptr);
+    flushPorts(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
+               kPortIndexOutput);
+    framesReceived = 0;
+    timestampUs = 0;
+
+    // set state to idle
+    changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
+    // set state to executing
+    changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
+                            kPortIndexInput, kPortIndexOutput);
 }
 
 // test input/output port flush
@@ -1471,96 +1375,84 @@ TEST_F(VideoDecHidlTest, FlushTest) {
         Info.push_back({bytesCount, flags, timestamp});
         if (maxBytesCount < bytesCount) maxBytesCount = bytesCount;
     }
-    maxBytesCount = ALIGN_POWER_OF_TWO(maxBytesCount, 10);
     eleInfo.close();
 
-    PortMode pmArray[] = {PortMode::PRESET_BYTE_BUFFER,
-                          PortMode::DYNAMIC_ANW_BUFFER,
-                          PortMode::PRESET_ANW_BUFFER};
-    for (size_t j = 0; j < sizeof(pmArray) / sizeof(pmArray[0]); j++) {
-        // set port mode
-        portMode[0] = PortMode::PRESET_BYTE_BUFFER;
-        portMode[1] = pmArray[j];
-        status = omxNode->setPortMode(kPortIndexInput, portMode[0]);
-        ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
-        status = omxNode->setPortMode(kPortIndexOutput, portMode[1]);
-        if (status != ::android::hardware::media::omx::V1_0::Status::OK) {
-            continue;
-        }
-
-        // As the frame sizes are known ahead, use it to configure i/p buffer
-        // size
-        status = setPortBufferSize(omxNode, kPortIndexInput, maxBytesCount);
-        ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
+    // As the frame sizes are known ahead, use it to configure i/p buffer size
+    maxBytesCount = ALIGN_POWER_OF_TWO(maxBytesCount, 10);
+    status = setPortBufferSize(omxNode, kPortIndexInput, maxBytesCount);
+    ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
 
-        // set Port Params
-        uint32_t nFrameWidth, nFrameHeight, xFramerate;
-        getInputChannelInfo(omxNode, kPortIndexInput, &nFrameWidth,
-                            &nFrameHeight, &xFramerate);
-        // get default color format
-        OMX_COLOR_FORMATTYPE eColorFormat = OMX_COLOR_FormatUnused;
-        getDefaultColorFormat(omxNode, kPortIndexOutput, portMode[1],
-                              &eColorFormat);
-        ASSERT_NE(eColorFormat, OMX_COLOR_FormatUnused);
-        status = setVideoPortFormat(omxNode, kPortIndexOutput,
-                                    OMX_VIDEO_CodingUnused, eColorFormat,
-                                    xFramerate);
-        EXPECT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
-        setDefaultPortParam(omxNode, kPortIndexOutput, OMX_VIDEO_CodingUnused,
-                            eColorFormat, nFrameWidth, nFrameHeight, 0,
-                            xFramerate);
-
-        android::Vector<BufferInfo> iBuffer, oBuffer;
-
-        // set state to idle
-        changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,
-                                kPortIndexInput, kPortIndexOutput, portMode,
-                                true);
-        // set state to executing
-        changeStateIdletoExecute(omxNode, observer);
-
-        // Decode 128 frames and flush. here 128 is chosen to ensure there is a
-        // key frame after this so that the below section can be convered for
-        // all components
-        int nFrames = 128;
-        eleStream.open(mURL, std::ifstream::binary);
-        ASSERT_EQ(eleStream.is_open(), true);
-        decodeNFrames(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
-                      kPortIndexOutput, eleStream, &Info, 0, nFrames,
-                      portMode[1], false);
-        flushPorts(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
-                   kPortIndexOutput);
-        framesReceived = 0;
+    // set port mode
+    status = omxNode->setPortMode(kPortIndexInput, portMode[0]);
+    ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
+    status = omxNode->setPortMode(kPortIndexOutput, portMode[1]);
+    ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
 
-        // Seek to next key frame and start decoding till the end
-        int index = nFrames;
-        bool keyFrame = false;
-        while (index < (int)Info.size()) {
-            if ((Info[index].flags & OMX_BUFFERFLAG_SYNCFRAME) ==
-                OMX_BUFFERFLAG_SYNCFRAME) {
-                timestampUs = Info[index - 1].timestamp;
-                keyFrame = true;
-                break;
-            }
-            eleStream.ignore(Info[index].bytesCount);
-            index++;
-        }
-        if (keyFrame) {
-            decodeNFrames(omxNode, observer, &iBuffer, &oBuffer,
-                          kPortIndexInput, kPortIndexOutput, eleStream, &Info,
-                          index, Info.size() - index, portMode[1], false);
+    // set Port Params
+    uint32_t nFrameWidth, nFrameHeight, xFramerate;
+    getInputChannelInfo(omxNode, kPortIndexInput, &nFrameWidth, &nFrameHeight,
+                        &xFramerate);
+    // get default color format
+    OMX_COLOR_FORMATTYPE eColorFormat = OMX_COLOR_FormatUnused;
+    getDefaultColorFormat(omxNode, kPortIndexOutput, portMode[1],
+                          &eColorFormat);
+    ASSERT_NE(eColorFormat, OMX_COLOR_FormatUnused);
+    status =
+        setVideoPortFormat(omxNode, kPortIndexOutput, OMX_VIDEO_CodingUnused,
+                           eColorFormat, xFramerate);
+    EXPECT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);
+    setDefaultPortParam(omxNode, kPortIndexOutput, OMX_VIDEO_CodingUnused,
+                        eColorFormat, nFrameWidth, nFrameHeight, 0, xFramerate);
+
+    android::Vector<BufferInfo> iBuffer, oBuffer;
+
+    // set state to idle
+    changeStateLoadedtoIdle(omxNode, observer, &iBuffer, &oBuffer,
+                            kPortIndexInput, kPortIndexOutput, portMode, true);
+    // set state to executing
+    changeStateIdletoExecute(omxNode, observer);
+
+    // Decode 128 frames and flush. here 128 is chosen to ensure there is a key
+    // frame after this so that the below section can be convered for all
+    // components
+    int nFrames = 128;
+    eleStream.open(mURL, std::ifstream::binary);
+    ASSERT_EQ(eleStream.is_open(), true);
+    decodeNFrames(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
+                  kPortIndexOutput, eleStream, &Info, 0, nFrames, portMode[1],
+                  false);
+    flushPorts(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
+               kPortIndexOutput);
+    framesReceived = 0;
+
+    // Seek to next key frame and start decoding till the end
+    int index = nFrames;
+    bool keyFrame = false;
+    while (index < (int)Info.size()) {
+        if ((Info[index].flags & OMX_BUFFERFLAG_SYNCFRAME) ==
+            OMX_BUFFERFLAG_SYNCFRAME) {
+            timestampUs = Info[index - 1].timestamp;
+            keyFrame = true;
+            break;
         }
-        eleStream.close();
-        flushPorts(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
-                   kPortIndexOutput);
-        framesReceived = 0;
-
-        // set state to idle
-        changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
-        // set state to loaded
-        changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
-                                kPortIndexInput, kPortIndexOutput);
+        eleStream.ignore(Info[index].bytesCount);
+        index++;
+    }
+    if (keyFrame) {
+        decodeNFrames(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
+                      kPortIndexOutput, eleStream, &Info, index,
+                      Info.size() - index, portMode[1], false);
     }
+    eleStream.close();
+    flushPorts(omxNode, observer, &iBuffer, &oBuffer, kPortIndexInput,
+               kPortIndexOutput);
+    framesReceived = 0;
+
+    // set state to idle
+    changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
+    // set state to executing
+    changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
+                            kPortIndexInput, kPortIndexOutput);
 }
 
 int main(int argc, char** argv) {
diff --git a/media/omx/1.0/vts/functional/video/VtsHalMediaOmxV1_0TargetVideoEncTest.cpp b/media/omx/1.0/vts/functional/video/VtsHalMediaOmxV1_0TargetVideoEncTest.cpp
index 24eeea71..df90ccce 100644
--- a/media/omx/1.0/vts/functional/video/VtsHalMediaOmxV1_0TargetVideoEncTest.cpp
+++ b/media/omx/1.0/vts/functional/video/VtsHalMediaOmxV1_0TargetVideoEncTest.cpp
@@ -1161,7 +1161,7 @@ TEST_F(VideoEncHidlTest, BufferSourceCallBacks) {
     // set state to idle
     changeStateExecutetoIdle(omxNode, observer, &buffersource->iBuffer,
                              &buffersource->oBuffer);
-    // set state to loaded
+    // set state to executing
     changeStateIdletoLoaded(omxNode, observer, &buffersource->iBuffer,
                             &buffersource->oBuffer, kPortIndexInput,
                             kPortIndexOutput);
@@ -1273,7 +1273,7 @@ TEST_F(VideoEncHidlTest, EncodeTest) {
 
     // set state to idle
     changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
-    // set state to loaded
+    // set state to executing
     changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
                             kPortIndexInput, kPortIndexOutput);
 }
@@ -1432,7 +1432,7 @@ TEST_F(VideoEncHidlTest, EncodeTestBufferMetaModes) {
     // set state to idle
     changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
     EXPECT_EQ(portDef.nBufferCountActual, listener->freeBuffers);
-    // set state to loaded
+    // set state to executing
     changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
                             kPortIndexInput, kPortIndexOutput);
 
@@ -1543,7 +1543,7 @@ TEST_F(VideoEncHidlTest, EncodeTestEOS) {
     // set state to idle
     changeStateExecutetoIdle(omxNode, observer, &iBuffer, &oBuffer);
     EXPECT_EQ(portDef.nBufferCountActual, listener->freeBuffers);
-    // set state to loaded
+    // set state to executing
     changeStateIdletoLoaded(omxNode, observer, &iBuffer, &oBuffer,
                             kPortIndexInput, kPortIndexOutput);
 
diff --git a/media/omx/1.0/vts/functional/video/media_video_hidl_test_common.cpp b/media/omx/1.0/vts/functional/video/media_video_hidl_test_common.cpp
index f9b78339..91aecf22 100644
--- a/media/omx/1.0/vts/functional/video/media_video_hidl_test_common.cpp
+++ b/media/omx/1.0/vts/functional/video/media_video_hidl_test_common.cpp
@@ -89,7 +89,7 @@ void setupRAWPort(sp<IOmxNode> omxNode, OMX_U32 portIndex, OMX_U32 nFrameWidth,
     portDef.format.video.nFrameWidth = nFrameWidth;
     portDef.format.video.nFrameHeight = nFrameHeight;
     portDef.format.video.nStride = (((nFrameWidth + 15) >> 4) << 4);
-    portDef.format.video.nSliceHeight = nFrameHeight;
+    portDef.format.video.nSliceHeight = (((nFrameHeight + 15) >> 4) << 4);
     portDef.format.video.nBitrate = nBitrate;
     portDef.format.video.xFramerate = xFramerate;
     portDef.format.video.bFlagErrorConcealment = OMX_TRUE;