diff --git a/tv/tuner/1.0/vts/functional/VtsHalTvTunerV1_0TargetTest.cpp b/tv/tuner/1.0/vts/functional/VtsHalTvTunerV1_0TargetTest.cpp
index 8b0413c..8f83d82 100644
--- a/tv/tuner/1.0/vts/functional/VtsHalTvTunerV1_0TargetTest.cpp
+++ b/tv/tuner/1.0/vts/functional/VtsHalTvTunerV1_0TargetTest.cpp
@@ -889,6 +889,7 @@
                                        RecordSettings recordSetting,
                                        vector<string> goldenOutputFiles);
     AssertionResult broadcastDataFlowTest(vector<string> goldenOutputFiles);
+    void broadcastFilterTest(int selectedFilter, int feId);
 
     FilterEventType getFilterEventType(DemuxFilterType type);
 };
@@ -1183,6 +1184,28 @@
     return success();
 }
 
+void TunerHidlTest::broadcastFilterTest(int selectedFilter, int feId) {
+    ASSERT_TRUE(openFrontend(feId));
+    ASSERT_TRUE(setFrontendCallback());
+    ASSERT_TRUE(openDemux());
+    ASSERT_TRUE(setDemuxFrontendDataSource(feId));
+    ASSERT_TRUE(openFilterInDemux(filterArray[selectedFilter].type));
+    uint32_t filterId;
+    ASSERT_TRUE(getNewlyOpenedFilterId(filterId));
+    ASSERT_TRUE(configFilter(filterArray[selectedFilter].setting, filterId));
+    ASSERT_TRUE(getFilterMQDescriptor(filterId));
+    ASSERT_TRUE(startFilter(filterId));
+    // tune test
+    ASSERT_TRUE(tuneFrontend(frontendArray[DVBT]));
+    // broadcast data flow test
+    ASSERT_TRUE(broadcastDataFlowTest(goldenOutputFiles));
+    ASSERT_TRUE(stopTuneFrontend());
+    ASSERT_TRUE(stopFilter(filterId));
+    ASSERT_TRUE(closeFilter(filterId));
+    ASSERT_TRUE(closeDemux());
+    ASSERT_TRUE(closeFrontend());
+}
+
 /*
  * TODO: re-enable the tests after finalizing the test refactoring.
  */
@@ -1401,16 +1424,14 @@
     description("Tune one Frontend with specific setting and check Lock event");
     ASSERT_TRUE(getFrontendIds());
     ASSERT_TRUE(mFeIds.size() > 0);
-    ALOGW("[vts] expected Frontend type is %d", frontendArray[0].type);
     for (size_t i = 0; i < mFeIds.size(); i++) {
         ASSERT_TRUE(getFrontendInfo(mFeIds[i]));
-        ALOGW("[vts] Frontend type is %d", mFrontendInfo.type);
-        if (mFrontendInfo.type != frontendArray[0].type) {
+        if (mFrontendInfo.type != frontendArray[DVBT].type) {
             continue;
         }
         ASSERT_TRUE(openFrontend(mFeIds[i]));
         ASSERT_TRUE(setFrontendCallback());
-        ASSERT_TRUE(tuneFrontend(frontendArray[0]));
+        ASSERT_TRUE(tuneFrontend(frontendArray[DVBT]));
         ASSERT_TRUE(stopTuneFrontend());
         ASSERT_TRUE(closeFrontend());
         break;
@@ -1424,12 +1445,12 @@
 
     for (size_t i = 0; i < mFeIds.size(); i++) {
         ASSERT_TRUE(getFrontendInfo(mFeIds[i]));
-        if (mFrontendInfo.type != frontendArray[0].type) {
+        if (mFrontendInfo.type != frontendScanArray[SCAN_DVBT].type) {
             continue;
         }
         ASSERT_TRUE(openFrontend(mFeIds[i]));
         ASSERT_TRUE(setFrontendCallback());
-        ASSERT_TRUE(scanFrontend(frontendScanArray[0], FrontendScanType::SCAN_AUTO));
+        ASSERT_TRUE(scanFrontend(frontendScanArray[SCAN_DVBT], FrontendScanType::SCAN_AUTO));
         ASSERT_TRUE(stopScanFrontend());
         ASSERT_TRUE(closeFrontend());
         break;
@@ -1443,12 +1464,12 @@
 
     for (size_t i = 0; i < mFeIds.size(); i++) {
         ASSERT_TRUE(getFrontendInfo(mFeIds[i]));
-        if (mFrontendInfo.type != frontendArray[0].type) {
+        if (mFrontendInfo.type != frontendScanArray[SCAN_DVBT].type) {
             continue;
         }
         ASSERT_TRUE(openFrontend(mFeIds[i]));
         ASSERT_TRUE(setFrontendCallback());
-        ASSERT_TRUE(scanFrontend(frontendScanArray[0], FrontendScanType::SCAN_BLIND));
+        ASSERT_TRUE(scanFrontend(frontendScanArray[SCAN_DVBT], FrontendScanType::SCAN_BLIND));
         ASSERT_TRUE(stopScanFrontend());
         ASSERT_TRUE(closeFrontend());
         break;
@@ -1464,7 +1485,7 @@
 
     for (size_t i = 0; i < mFeIds.size(); i++) {
         ASSERT_TRUE(getFrontendInfo(mFeIds[i]));
-        if (mFrontendInfo.type != frontendArray[0].type) {
+        if (mFrontendInfo.type != frontendArray[DVBT].type) {
             continue;
         }
         ASSERT_TRUE(openFrontend(mFeIds[i]));
@@ -1484,14 +1505,14 @@
 
     for (size_t i = 0; i < mFeIds.size(); i++) {
         ASSERT_TRUE(getFrontendInfo(mFeIds[i]));
-        if (mFrontendInfo.type != frontendArray[0].type) {
+        if (mFrontendInfo.type != frontendArray[DVBT].type) {
             continue;
         }
         ASSERT_TRUE(openFrontend(mFeIds[i]));
         ASSERT_TRUE(setFrontendCallback());
         ASSERT_TRUE(openDemux());
         ASSERT_TRUE(setDemuxFrontendDataSource(mFeIds[i]));
-        ASSERT_TRUE(openFilterInDemux(filterArray[0].type));
+        ASSERT_TRUE(openFilterInDemux(filterArray[TS_VIDEO0].type));
         uint32_t filterId;
         ASSERT_TRUE(getNewlyOpenedFilterId(filterId));
         ASSERT_TRUE(closeFilter(filterId));
@@ -1508,17 +1529,17 @@
 
     for (size_t i = 0; i < mFeIds.size(); i++) {
         ASSERT_TRUE(getFrontendInfo(mFeIds[i]));
-        if (mFrontendInfo.type != frontendArray[0].type) {
+        if (mFrontendInfo.type != frontendArray[DVBT].type) {
             continue;
         }
         ASSERT_TRUE(openFrontend(mFeIds[i]));
         ASSERT_TRUE(setFrontendCallback());
         ASSERT_TRUE(openDemux());
         ASSERT_TRUE(setDemuxFrontendDataSource(mFeIds[i]));
-        ASSERT_TRUE(openFilterInDemux(filterArray[0].type));
+        ASSERT_TRUE(openFilterInDemux(filterArray[TS_VIDEO0].type));
         uint32_t filterId;
         ASSERT_TRUE(getNewlyOpenedFilterId(filterId));
-        ASSERT_TRUE(configFilter(filterArray[0].setting, filterId));
+        ASSERT_TRUE(configFilter(filterArray[TS_VIDEO0].setting, filterId));
         ASSERT_TRUE(getFilterMQDescriptor(filterId));
         ASSERT_TRUE(startFilter(filterId));
         ASSERT_TRUE(stopFilter(filterId));
@@ -1546,35 +1567,62 @@
 /*============================== End Descrambler Tests ==============================*/
 
 /*============================== Start Data Flow Tests ==============================*/
-TEST_P(TunerHidlTest, BroadcastDataFlowWithAudioFilterTest) {
-    description("Open Demux with a Frontend as its data source.");
+TEST_P(TunerHidlTest, BroadcastDataFlowVideoFilterTest) {
+    description("Test Video Filter functionality in Broadcast use case.");
     ASSERT_TRUE(getFrontendIds());
     ASSERT_TRUE(mFeIds.size() > 0);
 
     for (size_t i = 0; i < mFeIds.size(); i++) {
         ASSERT_TRUE(getFrontendInfo(mFeIds[i]));
-        if (mFrontendInfo.type != frontendArray[0].type) {
+        if (mFrontendInfo.type != frontendArray[DVBT].type) {
             continue;
         }
-        ASSERT_TRUE(openFrontend(mFeIds[i]));
-        ASSERT_TRUE(setFrontendCallback());
-        ASSERT_TRUE(openDemux());
-        ASSERT_TRUE(setDemuxFrontendDataSource(mFeIds[i]));
-        ASSERT_TRUE(openFilterInDemux(filterArray[0].type));
-        uint32_t filterId;
-        ASSERT_TRUE(getNewlyOpenedFilterId(filterId));
-        ASSERT_TRUE(configFilter(filterArray[0].setting, filterId));
-        ASSERT_TRUE(getFilterMQDescriptor(filterId));
-        ASSERT_TRUE(startFilter(filterId));
-        // tune test
-        ASSERT_TRUE(tuneFrontend(frontendArray[0]));
-        // broadcast data flow test
-        ASSERT_TRUE(broadcastDataFlowTest(goldenOutputFiles));
-        ASSERT_TRUE(stopTuneFrontend());
-        ASSERT_TRUE(stopFilter(filterId));
-        ASSERT_TRUE(closeFilter(filterId));
-        ASSERT_TRUE(closeDemux());
-        ASSERT_TRUE(closeFrontend());
+        broadcastFilterTest(TS_VIDEO1, mFeIds[i]);
+        break;
+    }
+}
+
+TEST_P(TunerHidlTest, BroadcastDataFlowAudioFilterTest) {
+    description("Test Audio Filter functionality in Broadcast use case.");
+    ASSERT_TRUE(getFrontendIds());
+    ASSERT_TRUE(mFeIds.size() > 0);
+
+    for (size_t i = 0; i < mFeIds.size(); i++) {
+        ASSERT_TRUE(getFrontendInfo(mFeIds[i]));
+        if (mFrontendInfo.type != frontendArray[DVBT].type) {
+            continue;
+        }
+        broadcastFilterTest(TS_AUDIO0, mFeIds[i]);
+        break;
+    }
+}
+
+TEST_P(TunerHidlTest, BroadcastDataFlowTsFilterTest) {
+    description("Test TS Filter functionality in Broadcast use case.");
+    ASSERT_TRUE(getFrontendIds());
+    ASSERT_TRUE(mFeIds.size() > 0);
+
+    for (size_t i = 0; i < mFeIds.size(); i++) {
+        ASSERT_TRUE(getFrontendInfo(mFeIds[i]));
+        if (mFrontendInfo.type != frontendArray[DVBT].type) {
+            continue;
+        }
+        broadcastFilterTest(TS_TS0, mFeIds[i]);
+        break;
+    }
+}
+
+TEST_P(TunerHidlTest, BroadcastDataFlowSectionFilterTest) {
+    description("Test Section Filter functionality in Broadcast use case.");
+    ASSERT_TRUE(getFrontendIds());
+    ASSERT_TRUE(mFeIds.size() > 0);
+
+    for (size_t i = 0; i < mFeIds.size(); i++) {
+        ASSERT_TRUE(getFrontendInfo(mFeIds[i]));
+        if (mFrontendInfo.type != frontendArray[DVBT].type) {
+            continue;
+        }
+        broadcastFilterTest(TS_SECTION0, mFeIds[i]);
         break;
     }
 }
@@ -1671,20 +1719,20 @@
 
     for (size_t i = 0; i < mFeIds.size(); i++) {
         ASSERT_TRUE(getFrontendInfo(mFeIds[i]));
-        if (mFrontendInfo.type != frontendArray[1].type) {
+        if (mFrontendInfo.type != frontendArray[DVBS].type) {
             continue;
         }
         ASSERT_TRUE(openFrontend(mFeIds[i]));
         ASSERT_TRUE(setFrontendCallback());
         ASSERT_TRUE(openDemux());
-        ASSERT_TRUE(openFilterInDemux(filterArray[0].type));
+        ASSERT_TRUE(openFilterInDemux(filterArray[TS_VIDEO0].type));
         uint32_t filterId;
         ASSERT_TRUE(getNewlyOpenedFilterId(filterId));
-        ASSERT_TRUE(configFilter(filterArray[0].setting, filterId));
+        ASSERT_TRUE(configFilter(filterArray[TS_VIDEO0].setting, filterId));
         ASSERT_TRUE(startFilter(filterId));
         ASSERT_TRUE(setDemuxFrontendDataSource(mFeIds[i]));
         // tune test
-        ASSERT_TRUE(tuneFrontend(frontendArray[1]));
+        ASSERT_TRUE(tuneFrontend(frontendArray[DVBS]));
         // broadcast data flow test
         ASSERT_TRUE(broadcastDataFlowTest(goldenOutputFiles));
         ASSERT_TRUE(stopTuneFrontend());
diff --git a/tv/tuner/1.0/vts/functional/VtsHalTvTunerV1_0TestConfigurations.h b/tv/tuner/1.0/vts/functional/VtsHalTvTunerV1_0TestConfigurations.h
index 31e3b51..10c6014 100644
--- a/tv/tuner/1.0/vts/functional/VtsHalTvTunerV1_0TestConfigurations.h
+++ b/tv/tuner/1.0/vts/functional/VtsHalTvTunerV1_0TestConfigurations.h
@@ -14,42 +14,18 @@
  * limitations under the License.
  */
 
-#include <android-base/logging.h>
-#include <android/hardware/tv/tuner/1.0/IDemux.h>
-#include <android/hardware/tv/tuner/1.0/IDescrambler.h>
-#include <android/hardware/tv/tuner/1.0/IDvr.h>
-#include <android/hardware/tv/tuner/1.0/IDvrCallback.h>
-#include <android/hardware/tv/tuner/1.0/IFilter.h>
-#include <android/hardware/tv/tuner/1.0/IFilterCallback.h>
-#include <android/hardware/tv/tuner/1.0/IFrontend.h>
-#include <android/hardware/tv/tuner/1.0/IFrontendCallback.h>
-#include <android/hardware/tv/tuner/1.0/ITuner.h>
 #include <android/hardware/tv/tuner/1.0/types.h>
 #include <binder/MemoryDealer.h>
-#include <fmq/MessageQueue.h>
 #include <hidl/HidlSupport.h>
 #include <hidl/HidlTransportSupport.h>
 #include <hidl/Status.h>
 #include <hidlmemory/FrameworkUtils.h>
-#include <utils/Condition.h>
-#include <utils/Mutex.h>
-#include <fstream>
-#include <iostream>
-#include <map>
 
 using android::hardware::tv::tuner::V1_0::DemuxFilterEvent;
 using android::hardware::tv::tuner::V1_0::DemuxFilterMainType;
-using android::hardware::tv::tuner::V1_0::DemuxFilterPesDataSettings;
-using android::hardware::tv::tuner::V1_0::DemuxFilterPesEvent;
-using android::hardware::tv::tuner::V1_0::DemuxFilterRecordSettings;
-using android::hardware::tv::tuner::V1_0::DemuxFilterSectionEvent;
-using android::hardware::tv::tuner::V1_0::DemuxFilterSectionSettings;
 using android::hardware::tv::tuner::V1_0::DemuxFilterSettings;
-using android::hardware::tv::tuner::V1_0::DemuxFilterStatus;
 using android::hardware::tv::tuner::V1_0::DemuxFilterType;
-using android::hardware::tv::tuner::V1_0::DemuxQueueNotifyBits;
 using android::hardware::tv::tuner::V1_0::DemuxTpid;
-using android::hardware::tv::tuner::V1_0::DemuxTsFilterSettings;
 using android::hardware::tv::tuner::V1_0::DemuxTsFilterType;
 using android::hardware::tv::tuner::V1_0::FrontendDvbtBandwidth;
 using android::hardware::tv::tuner::V1_0::FrontendDvbtCoderate;
@@ -62,12 +38,27 @@
 using android::hardware::tv::tuner::V1_0::FrontendSettings;
 using android::hardware::tv::tuner::V1_0::FrontendType;
 
-namespace {
+typedef enum {
+    TS_VIDEO0,
+    TS_VIDEO1,
+    TS_AUDIO0,
+    TS_PES0,
+    TS_PCR0,
+    TS_SECTION0,
+    TS_TS0,
+    FILTER_MAX,
+} Filter;
 
-#define frontend_transponders_count 2
-#define channels_count 1
-#define frontend_scan_count 1
-#define filter_count 2
+typedef enum {
+    DVBT,
+    DVBS,
+    FRONTEND_MAX,
+} Frontend;
+
+typedef enum {
+    SCAN_DVBT,
+    SCAN_MAX,
+} FrontendScan;
 
 struct FilterConfig {
     DemuxFilterType type;
@@ -87,10 +78,10 @@
     DemuxTpid audioPid;
 };
 
-static FrontendConfig frontendArray[frontend_transponders_count];
-static FrontendConfig frontendScanArray[channels_count];
-static ChannelConfig channelArray[frontend_scan_count];
-static FilterConfig filterArray[filter_count];
+static FrontendConfig frontendArray[FILTER_MAX];
+static FrontendConfig frontendScanArray[SCAN_MAX];
+static ChannelConfig channelArray[FRONTEND_MAX];
+static FilterConfig filterArray[FILTER_MAX];
 static vector<string> goldenOutputFiles;
 
 /** Configuration array for the frontend tune test */
@@ -107,14 +98,14 @@
             .isHighPriority = true,
             .standard = FrontendDvbtStandard::T,
     };
-    frontendArray[0].type = FrontendType::DVBT, frontendArray[0].settings.dvbt(dvbtSettings);
-    frontendArray[1].type = FrontendType::DVBS;
+    frontendArray[DVBT].type = FrontendType::DVBT, frontendArray[DVBT].settings.dvbt(dvbtSettings);
+    frontendArray[DVBS].type = FrontendType::DVBS;
 };
 
 /** Configuration array for the frontend scan test */
 inline void initFrontendScanConfig() {
-    frontendScanArray[0].type = FrontendType::DVBT;
-    frontendScanArray[0].settings.dvbt({
+    frontendScanArray[SCAN_DVBT].type = FrontendType::DVBT;
+    frontendScanArray[SCAN_DVBT].settings.dvbt({
             .frequency = 578000,
             .transmissionMode = FrontendDvbtTransmissionMode::MODE_8K,
             .bandwidth = FrontendDvbtBandwidth::BANDWIDTH_8MHZ,
@@ -130,19 +121,43 @@
 
 /** Configuration array for the filter test */
 inline void initFilterConfig() {
-    // TS Video filter setting
-    filterArray[0].type.mainType = DemuxFilterMainType::TS;
-    filterArray[0].type.subType.tsFilterType(DemuxTsFilterType::VIDEO);
-    filterArray[0].setting.ts().tpid = 119;
-    filterArray[0].setting.ts().filterSettings.av({.isPassthrough = false});
+    // TS VIDEO filter setting for default implementation testing
+    filterArray[TS_VIDEO0].type.mainType = DemuxFilterMainType::TS;
+    filterArray[TS_VIDEO0].type.subType.tsFilterType(DemuxTsFilterType::VIDEO);
+    filterArray[TS_VIDEO0].setting.ts().tpid = 119;
+    filterArray[TS_VIDEO0].setting.ts().filterSettings.av({.isPassthrough = false});
+    filterArray[TS_VIDEO1].type.mainType = DemuxFilterMainType::TS;
+    filterArray[TS_VIDEO1].type.subType.tsFilterType(DemuxTsFilterType::VIDEO);
+    filterArray[TS_VIDEO1].setting.ts().tpid = 81;
+    filterArray[TS_VIDEO1].setting.ts().filterSettings.av({.isPassthrough = false});
+    // TS AUDIO filter setting
+    filterArray[TS_AUDIO0].type.mainType = DemuxFilterMainType::TS;
+    filterArray[TS_AUDIO0].type.subType.tsFilterType(DemuxTsFilterType::AUDIO);
+    filterArray[TS_AUDIO0].setting.ts().tpid = 84;
+    filterArray[TS_AUDIO0].setting.ts().filterSettings.av({.isPassthrough = false});
     // TS PES filter setting
-    filterArray[1].type.mainType = DemuxFilterMainType::TS;
-    filterArray[1].type.subType.tsFilterType(DemuxTsFilterType::PES);
-    filterArray[1].setting.ts().tpid = 256;
-    filterArray[1].setting.ts().filterSettings.pesData({
-            .isRaw = true,
+    filterArray[TS_PES0].type.mainType = DemuxFilterMainType::TS;
+    filterArray[TS_PES0].type.subType.tsFilterType(DemuxTsFilterType::PES);
+    filterArray[TS_PES0].setting.ts().tpid = 256;
+    filterArray[TS_PES0].setting.ts().filterSettings.pesData({
+            .isRaw = false,
             .streamId = 0xbd,
     });
+    // TS PCR filter setting
+    filterArray[TS_PCR0].type.mainType = DemuxFilterMainType::TS;
+    filterArray[TS_PCR0].type.subType.tsFilterType(DemuxTsFilterType::PCR);
+    filterArray[TS_PCR0].setting.ts().tpid = 81;
+    filterArray[TS_PCR0].setting.ts().filterSettings.noinit();
+    // TS filter setting
+    filterArray[TS_TS0].type.mainType = DemuxFilterMainType::TS;
+    filterArray[TS_TS0].type.subType.tsFilterType(DemuxTsFilterType::TS);
+    filterArray[TS_TS0].setting.ts().tpid = 48;
+    filterArray[TS_TS0].setting.ts().filterSettings.noinit();
+    // TS SECTION filter setting
+    filterArray[TS_SECTION0].type.mainType = DemuxFilterMainType::TS;
+    filterArray[TS_SECTION0].type.subType.tsFilterType(DemuxTsFilterType::SECTION);
+    filterArray[TS_SECTION0].setting.ts().tpid = 48;
+    filterArray[TS_SECTION0].setting.ts().filterSettings.section({
+            .isRaw = false,
+    });
 };
-
-}  // namespace