tv/tuner/config/TunerTestingConfigAidlReaderV1_0.h

/*
 * Copyright 2021 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#pragma once

#include <android-base/logging.h>
#include <android_media_tuner_testing_configuration_V1_0.h>
#include <android_media_tuner_testing_configuration_V1_0_enums.h>

#include <aidl/android/hardware/tv/tuner/DataFormat.h>
#include <aidl/android/hardware/tv/tuner/DemuxAlpFilterType.h>
#include <aidl/android/hardware/tv/tuner/DemuxFilterAvSettings.h>
#include <aidl/android/hardware/tv/tuner/DemuxFilterEvent.h>
#include <aidl/android/hardware/tv/tuner/DemuxFilterMainType.h>
#include <aidl/android/hardware/tv/tuner/DemuxFilterRecordSettings.h>
#include <aidl/android/hardware/tv/tuner/DemuxFilterSectionSettings.h>
#include <aidl/android/hardware/tv/tuner/DemuxFilterSettings.h>
#include <aidl/android/hardware/tv/tuner/DemuxFilterType.h>
#include <aidl/android/hardware/tv/tuner/DemuxIpAddress.h>
#include <aidl/android/hardware/tv/tuner/DemuxIpFilterSettings.h>
#include <aidl/android/hardware/tv/tuner/DemuxIpFilterType.h>
#include <aidl/android/hardware/tv/tuner/DemuxMmtpFilterType.h>
#include <aidl/android/hardware/tv/tuner/DemuxRecordScIndexType.h>
#include <aidl/android/hardware/tv/tuner/DemuxTlvFilterType.h>
#include <aidl/android/hardware/tv/tuner/DemuxTsFilterType.h>
#include <aidl/android/hardware/tv/tuner/DvrSettings.h>
#include <aidl/android/hardware/tv/tuner/DvrType.h>
#include <aidl/android/hardware/tv/tuner/FrontendDvbsSettings.h>
#include <aidl/android/hardware/tv/tuner/FrontendDvbtBandwidth.h>
#include <aidl/android/hardware/tv/tuner/FrontendDvbtCoderate.h>
#include <aidl/android/hardware/tv/tuner/FrontendDvbtConstellation.h>
#include <aidl/android/hardware/tv/tuner/FrontendDvbtGuardInterval.h>
#include <aidl/android/hardware/tv/tuner/FrontendDvbtHierarchy.h>
#include <aidl/android/hardware/tv/tuner/FrontendDvbtPlpMode.h>
#include <aidl/android/hardware/tv/tuner/FrontendDvbtSettings.h>
#include <aidl/android/hardware/tv/tuner/FrontendDvbtStandard.h>
#include <aidl/android/hardware/tv/tuner/FrontendDvbtTransmissionMode.h>
#include <aidl/android/hardware/tv/tuner/FrontendSettings.h>
#include <aidl/android/hardware/tv/tuner/FrontendStatus.h>
#include <aidl/android/hardware/tv/tuner/FrontendStatusType.h>
#include <aidl/android/hardware/tv/tuner/FrontendType.h>
#include <aidl/android/hardware/tv/tuner/LnbPosition.h>
#include <aidl/android/hardware/tv/tuner/LnbTone.h>
#include <aidl/android/hardware/tv/tuner/LnbVoltage.h>
#include <aidl/android/hardware/tv/tuner/PlaybackSettings.h>
#include <aidl/android/hardware/tv/tuner/RecordSettings.h>

using namespace std;
using namespace aidl::android::hardware::tv::tuner;
using namespace android::media::tuner::testing::configuration::V1_0;

static bool hasHwFe = false;
static bool hasSwFe = false;
static bool configFileRead = false;
static bool configuredLive = false;
static bool configuredScan = false;
static bool configuredRecord = false;
static bool configuredLnbLive = false;
static bool configuredPlayback = false;
static bool configuredLnbRecord = false;
static bool configuredTimeFilter = false;
static bool configuredDescrambling = false;

const string emptyHardwareId = "";

static string mConfigFilePath;

static vector<string> playbackDvrIds;
static vector<string> recordDvrIds;
static vector<string> audioFilterIds;
static vector<string> videoFilterIds;
static vector<string> recordFilterIds;
static vector<string> sectionFilterIds;

#define PROVISION_STR                                      \
    "{                                                   " \
    "  \"id\": 21140844,                                 " \
    "  \"name\": \"Test Title\",                         " \
    "  \"lowercase_organization_name\": \"Android\",     " \
    "  \"asset_key\": {                                  " \
    "  \"encryption_key\": \"nezAr3CHFrmBR9R8Tedotw==\"  " \
    "  },                                                " \
    "  \"cas_type\": 1,                                  " \
    "  \"track_types\": [ ]                              " \
    "}                                                   "

struct FrontendConfig {
    bool isSoftwareFe;
    FrontendType type;
    bool canConnectToCiCam;
    int32_t ciCamId;
    int32_t removePid;
    FrontendSettings settings;
    vector<FrontendStatusType> tuneStatusTypes;
    vector<FrontendStatus> expectTuneStatuses;
};

struct FilterConfig {
    int32_t bufferSize;
    DemuxFilterType type;
    DemuxFilterSettings settings;
    bool getMqDesc;
    AvStreamType streamType;
    int32_t ipCid;
    int32_t monitorEventTypes;
    int timeDelayInMs = 0;
    int dataDelayInBytes = 0;

    bool operator<(const FilterConfig& /*c*/) const { return false; }
};

struct DvrConfig {
    DvrType type;
    int32_t bufferSize;
    DvrSettings settings;
    string playbackInputFile;
};

struct LnbConfig {
    string name;
    LnbVoltage voltage;
    LnbTone tone;
    LnbPosition position;
};

struct TimeFilterConfig {
    int64_t timeStamp;
};

struct DescramblerConfig {
    int32_t casSystemId;
    string provisionStr;
    vector<uint8_t> hidlPvtData;
};

struct LiveBroadcastHardwareConnections {
    bool hasFrontendConnection;
    string frontendId;
    string dvrSoftwareFeId;
    string audioFilterId;
    string videoFilterId;
    string sectionFilterId;
    string ipFilterId;
    string pcrFilterId;
    /* list string of extra filters; */
};

struct ScanHardwareConnections {
    bool hasFrontendConnection;
    string frontendId;
};

struct DvrPlaybackHardwareConnections {
    bool support;
    bool hasExtraFilters = false;
    string frontendId;
    string dvrId;
    string audioFilterId;
    string videoFilterId;
    string sectionFilterId;
    vector<string> extraFilters;
};

struct DvrRecordHardwareConnections {
    bool support;
    bool hasFrontendConnection;
    string frontendId;
    string dvrRecordId;
    string dvrSoftwareFeId;
    string recordFilterId;
    string dvrSourceId;
};

struct DescramblingHardwareConnections {
    bool support;
    bool hasFrontendConnection;
    string frontendId;
    string dvrSoftwareFeId;
    string audioFilterId;
    string videoFilterId;
    string descramblerId;
    string dvrSourceId;
    vector<string> extraFilters;
};

struct LnbLiveHardwareConnections {
    bool support;
    string frontendId;
    string audioFilterId;
    string videoFilterId;
    string lnbId;
    vector<string> diseqcMsgs;
    vector<string> extraFilters;
};

struct LnbRecordHardwareConnections {
    bool support;
    string frontendId;
    string dvrRecordId;
    string recordFilterId;
    string lnbId;
    vector<string> diseqcMsgs;
    vector<string> extraFilters;
};

struct TimeFilterHardwareConnections {
    bool support;
    string timeFilterId;
};

struct TunerTestingConfigAidlReader1_0 {
  public:
    static void setConfigFilePath(string path) { mConfigFilePath = path; }

    static bool checkConfigFileExists() {
        auto res = read(mConfigFilePath.c_str());
        if (res == nullopt) {
            ALOGW("[ConfigReader] Couldn't read %s."
                  "Please check tuner_testing_dynamic_configuration.xsd"
                  "and sample_tuner_vts_config.xml for more details on how to config Tune VTS.",
                  mConfigFilePath.c_str());
        }
        return (res != nullopt);
    }

    static TunerConfiguration getTunerConfig() { return *read(mConfigFilePath.c_str()); }

    static DataFlowConfiguration getDataFlowConfiguration() {
        return *getTunerConfig().getFirstDataFlowConfiguration();
    }

    static HardwareConfiguration getHardwareConfig() {
        return *getTunerConfig().getFirstHardwareConfiguration();
    }

    static void readFrontendConfig1_0(map<string, FrontendConfig>& frontendMap) {
        auto hardwareConfig = getHardwareConfig();
        if (hardwareConfig.hasFrontends()) {
            // TODO: b/182519645 complete the tune status config
            vector<FrontendStatusType> types;
            vector<FrontendStatus> statuses;

            types.push_back(FrontendStatusType::DEMOD_LOCK);
            types.push_back(FrontendStatusType::UEC);
            types.push_back(FrontendStatusType::IS_MISO);

            FrontendStatus status;
            status.set<FrontendStatus::Tag::isDemodLocked>(true);
            statuses.push_back(status);
            status.set<FrontendStatus::Tag::uec>(4);
            statuses.push_back(status);
            status.set<FrontendStatus::Tag::isMiso>(true);
            statuses.push_back(status);

            auto frontends = *hardwareConfig.getFirstFrontends();
            for (auto feConfig : frontends.getFrontend()) {
                string id = feConfig.getId();
                if (id.compare(string("FE_DEFAULT")) == 0) {
                    // overrid default
                    frontendMap.erase(string("FE_DEFAULT"));
                }
                FrontendType type;
                switch (feConfig.getType()) {
                    case FrontendTypeEnum::UNDEFINED:
                        type = FrontendType::UNDEFINED;
                        break;
                    // TODO: b/182519645 finish all other frontend settings
                    case FrontendTypeEnum::ANALOG:
                        type = FrontendType::ANALOG;
                        break;
                    case FrontendTypeEnum::ATSC:
                        type = FrontendType::ATSC;
                        frontendMap[id].settings.set<
                            FrontendSettings::Tag::atsc>(
                                readAtscFrontendSettings(feConfig));
                        break;
                    case FrontendTypeEnum::ATSC3:
                        type = FrontendType::ATSC3;
                        break;
                    case FrontendTypeEnum::DVBC:
                        type = FrontendType::DVBC;
                        break;
                    case FrontendTypeEnum::DVBS:
                        type = FrontendType::DVBS;
                        frontendMap[id].settings.set<FrontendSettings::Tag::dvbs>(
                                readDvbsFrontendSettings(feConfig));
                        break;
                    case FrontendTypeEnum::DVBT: {
                        type = FrontendType::DVBT;
                        frontendMap[id].settings.set<FrontendSettings::Tag::dvbt>(
                                readDvbtFrontendSettings(feConfig));
                        break;
                    }
                    case FrontendTypeEnum::ISDBS:
                        type = FrontendType::ISDBS;
                        frontendMap[id].settings.set<FrontendSettings::Tag::isdbs>(
                                readIsdbsFrontendSettings(feConfig));
                        break;
                    case FrontendTypeEnum::ISDBS3:
                        type = FrontendType::ISDBS3;
                        break;
                    case FrontendTypeEnum::ISDBT:
                        type = FrontendType::ISDBT;
                        frontendMap[id].settings.set<FrontendSettings::Tag::isdbt>(
                                readIsdbtFrontendSettings(feConfig));
                        break;
                    case FrontendTypeEnum::DTMB:
                        type = FrontendType::DTMB;
                        break;
                    case FrontendTypeEnum::UNKNOWN:
                        ALOGW("[ConfigReader] invalid frontend type");
                        return;
                    default:
                        ALOGW("[ConfigReader] fe already handled in 1_0 reader.");
                        break;
                }
                frontendMap[id].type = type;
                frontendMap[id].isSoftwareFe = feConfig.getIsSoftwareFrontend();
                if (frontendMap[id].isSoftwareFe) {
                    hasSwFe = true;
                } else {
                    hasHwFe = true;
                }
                // TODO: b/182519645 complete the tune status config
                frontendMap[id].tuneStatusTypes = types;
                frontendMap[id].expectTuneStatuses = statuses;
                getCiCamInfo(feConfig, frontendMap[id].canConnectToCiCam, frontendMap[id].ciCamId,
                             frontendMap[id].removePid);
            }
        }
    }

    static void readFilterConfig1_0(map<string, FilterConfig>& filterMap) {
        auto hardwareConfig = getHardwareConfig();
        if (hardwareConfig.hasFilters()) {
            auto filters = *hardwareConfig.getFirstFilters();
            for (auto filterConfig : filters.getFilter()) {
                string id = filterConfig.getId();
                if (id.compare(string("FILTER_AUDIO_DEFAULT")) == 0) {
                    // overrid default
                    filterMap.erase(string("FILTER_AUDIO_DEFAULT"));
                }
                if (id.compare(string("FILTER_VIDEO_DEFAULT")) == 0) {
                    // overrid default
                    filterMap.erase(string("FILTER_VIDEO_DEFAULT"));
                }

                DemuxFilterType type;
                DemuxFilterSettings settings;
                if (!readFilterTypeAndSettings(filterConfig, type, settings)) {
                    ALOGW("[ConfigReader] invalid filter type");
                    return;
                }
                filterMap[id].type = type;
                filterMap[id].bufferSize = filterConfig.getBufferSize();
                filterMap[id].getMqDesc = filterConfig.getUseFMQ();
                filterMap[id].settings = settings;

                if (filterConfig.hasMonitorEventTypes()) {
                    filterMap[id].monitorEventTypes = (int32_t)filterConfig.getMonitorEventTypes();
                }
                if (filterConfig.hasTimeDelayInMs()) {
                    filterMap[id].timeDelayInMs = filterConfig.getTimeDelayInMs();
                }
                if (filterConfig.hasDataDelayInBytes()) {
                    filterMap[id].dataDelayInBytes = filterConfig.getDataDelayInBytes();
                }
                if (filterConfig.hasAvFilterSettings_optional()) {
                    auto av = filterConfig.getFirstAvFilterSettings_optional();
                    if (av->hasAudioStreamType_optional()) {
                        filterMap[id].streamType.set<AvStreamType::Tag::audio>(
                                static_cast<AudioStreamType>(av->getAudioStreamType_optional()));
                    }
                    if (av->hasVideoStreamType_optional()) {
                        filterMap[id].streamType.set<AvStreamType::Tag::video>(
                                static_cast<VideoStreamType>(av->getVideoStreamType_optional()));
                    }
                }
                if (filterConfig.hasIpFilterConfig_optional()) {
                    auto ip = filterConfig.getFirstIpFilterConfig_optional();
                    if (ip->hasIpCid()) {
                        filterMap[id].ipCid = ip->getIpCid();
                    }
                }
            }
        }
    }

    static void readDvrConfig1_0(map<string, DvrConfig>& dvrMap) {
        auto hardwareConfig = getHardwareConfig();
        if (hardwareConfig.hasDvrs()) {
            auto dvrs = *hardwareConfig.getFirstDvrs();
            for (auto dvrConfig : dvrs.getDvr()) {
                string id = dvrConfig.getId();
                DvrType type;
                switch (dvrConfig.getType()) {
                    case DvrTypeEnum::PLAYBACK:
                        playbackDvrIds.push_back(id);
                        type = DvrType::PLAYBACK;
                        dvrMap[id].settings.set<DvrSettings::Tag::playback>(
                                readPlaybackSettings(dvrConfig));
                        break;
                    case DvrTypeEnum::RECORD:
                        recordDvrIds.push_back(id);
                        type = DvrType::RECORD;
                        dvrMap[id].settings.set<DvrSettings::Tag::record>(
                                readRecordSettings(dvrConfig));
                        break;
                    case DvrTypeEnum::UNKNOWN:
                        ALOGW("[ConfigReader] invalid DVR type");
                        return;
                }
                dvrMap[id].type = type;
                dvrMap[id].bufferSize = static_cast<int32_t>(dvrConfig.getBufferSize());
                if (dvrConfig.hasInputFilePath()) {
                    dvrMap[id].playbackInputFile = dvrConfig.getInputFilePath();
                }
            }
        }
    }

    static void readLnbConfig1_0(map<string, LnbConfig>& lnbMap) {
        auto hardwareConfig = getHardwareConfig();
        if (hardwareConfig.hasLnbs()) {
            auto lnbs = *hardwareConfig.getFirstLnbs();
            for (auto lnbConfig : lnbs.getLnb()) {
                string id = lnbConfig.getId();
                if (lnbConfig.hasName()) {
                    lnbMap[id].name = lnbConfig.getName();
                } else {
                    lnbMap[id].name = emptyHardwareId;
                }
                lnbMap[id].voltage = static_cast<LnbVoltage>(lnbConfig.getVoltage());
                lnbMap[id].tone = static_cast<LnbTone>(lnbConfig.getTone());
                lnbMap[id].position = static_cast<LnbPosition>(lnbConfig.getPosition());
            }
        }
    }

    static void readDescramblerConfig1_0(map<string, DescramblerConfig>& descramblerMap) {
        auto hardwareConfig = getHardwareConfig();
        if (hardwareConfig.hasDescramblers()) {
            auto descramblers = *hardwareConfig.getFirstDescramblers();
            for (auto descramblerConfig : descramblers.getDescrambler()) {
                string id = descramblerConfig.getId();
                descramblerMap[id].casSystemId =
                        static_cast<int32_t>(descramblerConfig.getCasSystemId());
                if (descramblerConfig.hasProvisionStr()) {
                    descramblerMap[id].provisionStr = descramblerConfig.getProvisionStr();
                } else {
                    descramblerMap[id].provisionStr = PROVISION_STR;
                }
                if (descramblerConfig.hasSesstionPrivatData()) {
                    auto privateData = descramblerConfig.getSesstionPrivatData();
                    int size = privateData.size();
                    descramblerMap[id].hidlPvtData.resize(size);
                    memcpy(descramblerMap[id].hidlPvtData.data(), privateData.data(), size);
                } else {
                    descramblerMap[id].hidlPvtData.resize(256);
                }
            }
        }
    }

    static void readDiseqcMessages(map<string, vector<uint8_t>>& diseqcMsgMap) {
        auto hardwareConfig = getHardwareConfig();
        if (hardwareConfig.hasDiseqcMessages()) {
            auto msgs = *hardwareConfig.getFirstDiseqcMessages();
            for (auto msgConfig : msgs.getDiseqcMessage()) {
                string name = msgConfig.getMsgName();
                for (uint8_t atom : msgConfig.getMsgBody()) {
                    diseqcMsgMap[name].push_back(atom);
                }
            }
        }
    }

    static void readTimeFilterConfig1_0(map<string, TimeFilterConfig>& timeFilterMap) {
        auto hardwareConfig = getHardwareConfig();
        if (hardwareConfig.hasTimeFilters()) {
            auto timeFilters = *hardwareConfig.getFirstTimeFilters();
            for (auto timeFilterConfig : timeFilters.getTimeFilter()) {
                string id = timeFilterConfig.getId();
                timeFilterMap[id].timeStamp = static_cast<int64_t>(timeFilterConfig.getTimeStamp());
            }
        }
    }

    static void connectLiveBroadcast(LiveBroadcastHardwareConnections& live) {
        auto dataFlow = getDataFlowConfiguration();
        if (dataFlow.hasClearLiveBroadcast()) {
            live.hasFrontendConnection = true;
            configuredLive = true;
        } else {
            live.hasFrontendConnection = false;
            return;
        }
        auto liveConfig = *dataFlow.getFirstClearLiveBroadcast();
        live.frontendId = liveConfig.getFrontendConnection();

        live.audioFilterId = liveConfig.getAudioFilterConnection();
        live.videoFilterId = liveConfig.getVideoFilterConnection();
        if (liveConfig.hasPcrFilterConnection()) {
            live.pcrFilterId = liveConfig.getPcrFilterConnection();
        } else {
            live.pcrFilterId = emptyHardwareId;
        }
        if (liveConfig.hasSectionFilterConnection()) {
            live.sectionFilterId = liveConfig.getSectionFilterConnection();
        } else {
            live.sectionFilterId = emptyHardwareId;
        }
        if (liveConfig.hasDvrSoftwareFeConnection()) {
            live.dvrSoftwareFeId = liveConfig.getDvrSoftwareFeConnection();
        }
        if (liveConfig.hasIpFilterConnection()) {
            live.ipFilterId = liveConfig.getIpFilterConnection();
        } else {
            live.ipFilterId = emptyHardwareId;
        }
    }

    static void connectScan(ScanHardwareConnections& scan) {
        auto dataFlow = getDataFlowConfiguration();
        if (dataFlow.hasScan()) {
            scan.hasFrontendConnection = true;
            configuredScan = true;
        } else {
            scan.hasFrontendConnection = false;
            return;
        }
        auto scanConfig = *dataFlow.getFirstScan();
        scan.frontendId = scanConfig.getFrontendConnection();
    }

    static void connectDvrPlayback(DvrPlaybackHardwareConnections& playback) {
        auto dataFlow = getDataFlowConfiguration();
        if (dataFlow.hasDvrPlayback()) {
            playback.support = true;
            configuredPlayback = true;
        } else {
            playback.support = false;
            return;
        }
        auto playbackConfig = *dataFlow.getFirstDvrPlayback();
        playback.dvrId = playbackConfig.getDvrConnection();
        playback.audioFilterId = playbackConfig.getAudioFilterConnection();
        playback.videoFilterId = playbackConfig.getVideoFilterConnection();
        if (playbackConfig.hasSectionFilterConnection()) {
            playback.sectionFilterId = playbackConfig.getSectionFilterConnection();
        } else {
            playback.sectionFilterId = emptyHardwareId;
        }
        if (playbackConfig.hasOptionalFilters() && !playback.hasExtraFilters) {
            auto optionalFilters = playbackConfig.getFirstOptionalFilters()->getOptionalFilter();
            for (size_t i = 0; i < optionalFilters.size(); ++i) {
                playback.extraFilters.push_back(optionalFilters[i].getFilterId());
            }
            playback.hasExtraFilters = true;
        }
    }

    static void connectDvrRecord(DvrRecordHardwareConnections& record) {
        auto dataFlow = getDataFlowConfiguration();
        if (dataFlow.hasDvrRecord()) {
            record.support = true;
            configuredRecord = true;
        } else {
            record.support = false;
            return;
        }
        auto recordConfig = *dataFlow.getFirstDvrRecord();
        record.recordFilterId = recordConfig.getRecordFilterConnection();
        record.dvrRecordId = recordConfig.getDvrRecordConnection();
        if (recordConfig.hasDvrSoftwareFeConnection()) {
            record.dvrSoftwareFeId = recordConfig.getDvrSoftwareFeConnection();
        }
        if (recordConfig.getHasFrontendConnection()) {
            record.hasFrontendConnection = true;
            record.dvrSourceId = emptyHardwareId;
            record.frontendId = recordConfig.getFrontendConnection();
        } else {
            record.hasFrontendConnection = false;
            record.dvrSourceId = recordConfig.getDvrSourceConnection();
        }
    }

    static void connectDescrambling(DescramblingHardwareConnections& descrambling) {
        auto dataFlow = getDataFlowConfiguration();
        if (dataFlow.hasDescrambling()) {
            descrambling.support = true;
            configuredDescrambling = true;
        } else {
            descrambling.support = false;
            return;
        }
        auto descConfig = *dataFlow.getFirstDescrambling();
        descrambling.descramblerId = descConfig.getDescramblerConnection();
        descrambling.audioFilterId = descConfig.getAudioFilterConnection();
        descrambling.videoFilterId = descConfig.getVideoFilterConnection();
        if (descConfig.hasDvrSoftwareFeConnection()) {
            descrambling.dvrSoftwareFeId = descConfig.getDvrSoftwareFeConnection();
        }
        if (descConfig.getHasFrontendConnection()) {
            descrambling.hasFrontendConnection = true;
            descrambling.dvrSourceId = emptyHardwareId;
            descrambling.frontendId = descConfig.getFrontendConnection();
        } else {
            descrambling.hasFrontendConnection = false;
            descrambling.dvrSourceId = descConfig.getDvrSourceConnection();
        }
        if (descConfig.hasOptionalFilters()) {
            auto optionalFilters = descConfig.getOptionalFilters();
            descrambling.extraFilters = optionalFilters;
        }
    }

    static void connectLnbLive(LnbLiveHardwareConnections& lnbLive) {
        auto dataFlow = getDataFlowConfiguration();
        if (dataFlow.hasLnbLive()) {
            lnbLive.support = true;
            configuredLnbLive = true;
        } else {
            lnbLive.support = false;
            return;
        }
        auto lnbLiveConfig = *dataFlow.getFirstLnbLive();
        lnbLive.frontendId = lnbLiveConfig.getFrontendConnection();
        lnbLive.audioFilterId = lnbLiveConfig.getAudioFilterConnection();
        lnbLive.videoFilterId = lnbLiveConfig.getVideoFilterConnection();
        lnbLive.lnbId = lnbLiveConfig.getLnbConnection();
        if (lnbLiveConfig.hasDiseqcMsgSender()) {
            for (auto msgName : lnbLiveConfig.getDiseqcMsgSender()) {
                lnbLive.diseqcMsgs.push_back(msgName);
            }
        }
        if (lnbLiveConfig.hasOptionalFilters()) {
            auto optionalFilters = lnbLiveConfig.getOptionalFilters();
            lnbLive.extraFilters = optionalFilters;
        }
    }

    static void connectLnbRecord(LnbRecordHardwareConnections& lnbRecord) {
        auto dataFlow = getDataFlowConfiguration();
        if (dataFlow.hasLnbRecord()) {
            lnbRecord.support = true;
            configuredLnbRecord = true;
        } else {
            lnbRecord.support = false;
            return;
        }
        auto lnbRecordConfig = *dataFlow.getFirstLnbRecord();
        lnbRecord.frontendId = lnbRecordConfig.getFrontendConnection();
        lnbRecord.recordFilterId = lnbRecordConfig.getRecordFilterConnection();
        lnbRecord.dvrRecordId = lnbRecordConfig.getDvrRecordConnection();
        lnbRecord.lnbId = lnbRecordConfig.getLnbConnection();
        if (lnbRecordConfig.hasDiseqcMsgSender()) {
            for (auto msgName : lnbRecordConfig.getDiseqcMsgSender()) {
                lnbRecord.diseqcMsgs.push_back(msgName);
            }
        }
        if (lnbRecordConfig.hasOptionalFilters()) {
            auto optionalFilters = lnbRecordConfig.getOptionalFilters();
            lnbRecord.extraFilters = optionalFilters;
        }
    }

    static void connectTimeFilter(TimeFilterHardwareConnections& timeFilter) {
        auto dataFlow = getDataFlowConfiguration();
        if (dataFlow.hasTimeFilter()) {
            timeFilter.support = true;
            configuredTimeFilter = true;
        } else {
            timeFilter.support = false;
            return;
        }
        auto timeFilterConfig = *dataFlow.getFirstTimeFilter();
        timeFilter.timeFilterId = timeFilterConfig.getTimeFilterConnection();
    }

  private:
    static FrontendDvbtSettings readDvbtFrontendSettings(Frontend feConfig) {
        ALOGW("[ConfigReader] fe type is dvbt");
        FrontendDvbtSettings dvbtSettings{
                .frequency = (int64_t)feConfig.getFrequency(),
        };
        if (feConfig.hasEndFrequency()) {
            dvbtSettings.endFrequency = (int64_t)feConfig.getEndFrequency();
        }
        if (!feConfig.hasDvbtFrontendSettings_optional()) {
            ALOGW("[ConfigReader] no more dvbt settings");
            return dvbtSettings;
        }
        auto dvbt = feConfig.getFirstDvbtFrontendSettings_optional();
        int32_t trans = static_cast<int32_t>(dvbt->getTransmissionMode());
        dvbtSettings.transmissionMode = static_cast<FrontendDvbtTransmissionMode>(trans);
        dvbtSettings.bandwidth = static_cast<FrontendDvbtBandwidth>(dvbt->getBandwidth());
        dvbtSettings.isHighPriority = dvbt->getIsHighPriority();
        dvbtSettings.hierarchy = static_cast<FrontendDvbtHierarchy>(dvbt->getHierarchy());
        dvbtSettings.hpCoderate = static_cast<FrontendDvbtCoderate>(dvbt->getHpCoderate());
        dvbtSettings.lpCoderate = static_cast<FrontendDvbtCoderate>(dvbt->getLpCoderate());
        dvbtSettings.guardInterval =
                static_cast<FrontendDvbtGuardInterval>(dvbt->getGuardInterval());
        dvbtSettings.standard = static_cast<FrontendDvbtStandard>(dvbt->getStandard());
        dvbtSettings.isMiso = dvbt->getIsMiso();
        dvbtSettings.plpMode = static_cast<FrontendDvbtPlpMode>(dvbt->getPlpMode());
        dvbtSettings.plpId = dvbt->getPlpId();
        dvbtSettings.plpGroupId = dvbt->getPlpGroupId();
        if (dvbt->hasConstellation()) {
            dvbtSettings.constellation =
                    static_cast<FrontendDvbtConstellation>(dvbt->getConstellation());
        }
        return dvbtSettings;
    }

    static FrontendDvbsSettings readDvbsFrontendSettings(Frontend feConfig) {
        ALOGW("[ConfigReader] fe type is dvbs");
        FrontendDvbsSettings dvbsSettings{
                .frequency = (int64_t)feConfig.getFrequency(),
        };
        if (feConfig.hasEndFrequency()) {
            dvbsSettings.endFrequency = (int64_t)feConfig.getEndFrequency();
        }
        if (!feConfig.hasDvbsFrontendSettings_optional()) {
            ALOGW("[ConfigReader] no more dvbs settings");
            return dvbsSettings;
        }
        dvbsSettings.symbolRate = static_cast<int32_t>(
                feConfig.getFirstDvbsFrontendSettings_optional()->getSymbolRate());
        dvbsSettings.inputStreamId = static_cast<int32_t>(
                feConfig.getFirstDvbsFrontendSettings_optional()->getInputStreamId());
        auto dvbs = feConfig.getFirstDvbsFrontendSettings_optional();
        if (dvbs->hasScanType()) {
            dvbsSettings.scanType = static_cast<FrontendDvbsScanType>(dvbs->getScanType());
        }
        if (dvbs->hasIsDiseqcRxMessage()) {
            dvbsSettings.isDiseqcRxMessage = dvbs->getIsDiseqcRxMessage();
        }
        return dvbsSettings;
    }

    static FrontendAtscSettings readAtscFrontendSettings(Frontend& feConfig) {
        ALOGW("[ConfigReader] fe type is atsc");
        FrontendAtscSettings atscSettings{
                .frequency = (int64_t)feConfig.getFrequency(),
        };
        if (feConfig.hasEndFrequency()) {
            atscSettings.endFrequency = (int64_t)feConfig.getEndFrequency();
        }
        if (!feConfig.hasAtscFrontendSettings_optional()) {
            ALOGW("[ConfigReader] no more atsc settings");
            return atscSettings;
        }
        auto atsc = feConfig.getFirstAtscFrontendSettings_optional();
        atscSettings.inversion = static_cast<FrontendSpectralInversion>(atsc->getInversion());
        atscSettings.modulation = static_cast<FrontendAtscModulation>(atsc->getModulation());
        return atscSettings;
    }

    static FrontendIsdbsSettings readIsdbsFrontendSettings(Frontend& feConfig) {
        ALOGW("[ConfigReader] fe type is isdbs");
        FrontendIsdbsSettings isdbsSettings{.frequency = (int64_t)feConfig.getFrequency()};
        if (feConfig.hasEndFrequency()) {
            isdbsSettings.endFrequency = (int64_t)feConfig.getEndFrequency();
        }
        if (!feConfig.hasIsdbsFrontendSettings_optional()) {
            ALOGW("[ConfigReader] no more isdbs settings");
            return isdbsSettings;
        }
        auto isdbs = feConfig.getFirstIsdbsFrontendSettings_optional();
        isdbsSettings.streamId = (int32_t)isdbs->getStreamId();
        isdbsSettings.symbolRate = (int32_t)isdbs->getSymbolRate();
        isdbsSettings.modulation = static_cast<FrontendIsdbsModulation>(isdbs->getModulation());
        isdbsSettings.coderate = static_cast<FrontendIsdbsCoderate>(isdbs->getCoderate());
        isdbsSettings.rolloff = static_cast<FrontendIsdbsRolloff>(isdbs->getRolloff());
        isdbsSettings.streamIdType =
                static_cast<FrontendIsdbsStreamIdType>(isdbs->getStreamIdType());
        return isdbsSettings;
    }

    static FrontendIsdbtSettings readIsdbtFrontendSettings(Frontend& feConfig) {
        ALOGW("[ConfigReader] fe type is isdbt");
        FrontendIsdbtSettings isdbtSettings{
                .frequency = (int64_t)feConfig.getFrequency(),
        };
        if (feConfig.hasEndFrequency()) {
            isdbtSettings.endFrequency = (int64_t)feConfig.getEndFrequency();
        }
        if (!feConfig.hasIsdbtFrontendSettings_optional()) {
            ALOGW("[ConfigReader] no more isdbt settings");
            return isdbtSettings;
        }
        auto isdbt = feConfig.getFirstIsdbtFrontendSettings_optional();
        isdbtSettings.inversion = static_cast<FrontendSpectralInversion>(isdbt->getInversion());
        isdbtSettings.bandwidth = static_cast<FrontendIsdbtBandwidth>(isdbt->getBandwidth());
        isdbtSettings.mode = static_cast<FrontendIsdbtMode>(isdbt->getMode());
        isdbtSettings.guardInterval =
                static_cast<FrontendIsdbtGuardInterval>(isdbt->getGuardInterval());
        isdbtSettings.serviceAreaId = (int32_t)isdbt->getServiceAreaId();
        isdbtSettings.partialReceptionFlag =
                static_cast<FrontendIsdbtPartialReceptionFlag>(isdbt->getPartialReceptionFlag());
        if (!isdbt->hasFrontendIsdbtLayerSettings()) {
            ALOGW("[ConfigReader] no isdbt layer settings");
            return isdbtSettings;
        }
        auto layerSettings = isdbt->getFirstFrontendIsdbtLayerSettings();
        ::aidl::android::hardware::tv::tuner::FrontendIsdbtLayerSettings mLayerSettings;
        mLayerSettings.modulation =
                static_cast<FrontendIsdbtModulation>(layerSettings->getModulation());
        mLayerSettings.coderate = static_cast<FrontendIsdbtCoderate>(layerSettings->getCoderate());
        mLayerSettings.timeInterleave =
                static_cast<FrontendIsdbtTimeInterleaveMode>(layerSettings->getTimeInterleave());
        mLayerSettings.numOfSegment = (int32_t)layerSettings->getNumOfSegment();
        isdbtSettings.layerSettings.push_back(mLayerSettings);
        return isdbtSettings;
    }

    static bool readFilterTypeAndSettings(Filter filterConfig, DemuxFilterType& type,
                                          DemuxFilterSettings& settings) {
        auto mainType = filterConfig.getMainType();
        auto subType = filterConfig.getSubType();

        if (subType == FilterSubTypeEnum::AUDIO) {
            audioFilterIds.push_back(filterConfig.getId());
        } else if (subType == FilterSubTypeEnum::VIDEO) {
            videoFilterIds.push_back(filterConfig.getId());
        } else if (subType == FilterSubTypeEnum::RECORD) {
            recordFilterIds.push_back(filterConfig.getId());
        } else if (subType == FilterSubTypeEnum::SECTION) {
            sectionFilterIds.push_back(filterConfig.getId());
        }

        switch (mainType) {
            case FilterMainTypeEnum::TS: {
                ALOGW("[ConfigReader] filter main type is ts");
                type.mainType = DemuxFilterMainType::TS;
                DemuxTsFilterSettings ts;
                bool isTsSet = false;
                switch (subType) {
                    case FilterSubTypeEnum::UNDEFINED:
                        type.subType.set<DemuxFilterSubType::Tag::tsFilterType>(
                                DemuxTsFilterType::UNDEFINED);
                        break;
                    case FilterSubTypeEnum::SECTION:
                        type.subType.set<DemuxFilterSubType::Tag::tsFilterType>(
                                DemuxTsFilterType::SECTION);
                        ts.filterSettings.set<DemuxTsFilterSettingsFilterSettings::Tag::section>(
                                readSectionFilterSettings(filterConfig));
                        isTsSet = true;
                        break;
                    case FilterSubTypeEnum::PES:
                        // TODO: b/182519645 support all the filter settings
                        type.subType.set<DemuxFilterSubType::Tag::tsFilterType>(
                                DemuxTsFilterType::PES);
                        break;
                    case FilterSubTypeEnum::TS:
                        type.subType.set<DemuxFilterSubType::Tag::tsFilterType>(
                                DemuxTsFilterType::TS);
                        ts.filterSettings.set<DemuxTsFilterSettingsFilterSettings::Tag::noinit>(
                                true);
                        isTsSet = true;
                        break;
                    case FilterSubTypeEnum::PCR:
                        type.subType.set<DemuxFilterSubType::Tag::tsFilterType>(
                                DemuxTsFilterType::PCR);
                        ts.filterSettings.set<DemuxTsFilterSettingsFilterSettings::Tag::noinit>(
                                true);
                        isTsSet = true;
                        break;
                    case FilterSubTypeEnum::TEMI:
                        type.subType.set<DemuxFilterSubType::Tag::tsFilterType>(
                                DemuxTsFilterType::TEMI);
                        ts.filterSettings.set<DemuxTsFilterSettingsFilterSettings::Tag::noinit>(
                                true);
                        isTsSet = true;
                        break;
                    case FilterSubTypeEnum::AUDIO:
                        type.subType.set<DemuxFilterSubType::Tag::tsFilterType>(
                                DemuxTsFilterType::AUDIO);
                        ts.filterSettings.set<DemuxTsFilterSettingsFilterSettings::Tag::av>(
                                readAvFilterSettings(filterConfig));
                        isTsSet = true;
                        break;
                    case FilterSubTypeEnum::VIDEO:
                        type.subType.set<DemuxFilterSubType::Tag::tsFilterType>(
                                DemuxTsFilterType::VIDEO);
                        ts.filterSettings.set<DemuxTsFilterSettingsFilterSettings::Tag::av>(
                                readAvFilterSettings(filterConfig));
                        isTsSet = true;
                        break;
                    case FilterSubTypeEnum::RECORD:
                        type.subType.set<DemuxFilterSubType::Tag::tsFilterType>(
                                DemuxTsFilterType::RECORD);
                        ts.filterSettings.set<DemuxTsFilterSettingsFilterSettings::Tag::record>(
                                readRecordFilterSettings(filterConfig));
                        isTsSet = true;
                        break;
                    default:
                        ALOGW("[ConfigReader] ts subtype is not supported");
                        return false;
                }
                if (filterConfig.hasPid()) {
                    ts.tpid = static_cast<int32_t>(filterConfig.getPid());
                    isTsSet = true;
                }
                if (isTsSet) {
                    settings.set<DemuxFilterSettings::Tag::ts>(ts);
                }
                break;
            }
            case FilterMainTypeEnum::MMTP: {
                ALOGW("[ConfigReader] filter main type is mmtp");
                type.mainType = DemuxFilterMainType::MMTP;
                DemuxMmtpFilterSettings mmtp;
                bool isMmtpSet = false;
                switch (subType) {
                    case FilterSubTypeEnum::UNDEFINED:
                        type.subType.set<DemuxFilterSubType::Tag::mmtpFilterType>(
                                DemuxMmtpFilterType::UNDEFINED);
                        break;
                    case FilterSubTypeEnum::SECTION:
                        type.subType.set<DemuxFilterSubType::Tag::mmtpFilterType>(
                                DemuxMmtpFilterType::SECTION);
                        mmtp.filterSettings
                                .set<DemuxMmtpFilterSettingsFilterSettings::Tag::section>(
                                        readSectionFilterSettings(filterConfig));
                        isMmtpSet = true;
                        break;
                    case FilterSubTypeEnum::PES:
                        type.subType.set<DemuxFilterSubType::Tag::mmtpFilterType>(
                                DemuxMmtpFilterType::PES);
                        // TODO: b/182519645 support all the filter settings
                        break;
                    case FilterSubTypeEnum::MMTP:
                        type.subType.set<DemuxFilterSubType::Tag::mmtpFilterType>(
                                DemuxMmtpFilterType::MMTP);
                        mmtp.filterSettings.set<DemuxMmtpFilterSettingsFilterSettings::Tag::noinit>(
                                true);
                        isMmtpSet = true;
                        break;
                    case FilterSubTypeEnum::AUDIO:
                        type.subType.set<DemuxFilterSubType::Tag::mmtpFilterType>(
                                DemuxMmtpFilterType::AUDIO);
                        mmtp.filterSettings.set<DemuxMmtpFilterSettingsFilterSettings::Tag::av>(
                                readAvFilterSettings(filterConfig));
                        isMmtpSet = true;
                        break;
                    case FilterSubTypeEnum::VIDEO:
                        type.subType.set<DemuxFilterSubType::Tag::mmtpFilterType>(
                                DemuxMmtpFilterType::VIDEO);
                        mmtp.filterSettings.set<DemuxMmtpFilterSettingsFilterSettings::Tag::av>(
                                readAvFilterSettings(filterConfig));
                        isMmtpSet = true;
                        break;
                    case FilterSubTypeEnum::RECORD:
                        type.subType.set<DemuxFilterSubType::Tag::mmtpFilterType>(
                                DemuxMmtpFilterType::RECORD);
                        mmtp.filterSettings.set<DemuxMmtpFilterSettingsFilterSettings::Tag::record>(
                                readRecordFilterSettings(filterConfig));
                        isMmtpSet = true;
                        break;
                    case FilterSubTypeEnum::DOWNLOAD:
                        type.subType.set<DemuxFilterSubType::Tag::mmtpFilterType>(
                                DemuxMmtpFilterType::DOWNLOAD);
                        // TODO: b/182519645 support all the filter settings
                        break;
                    default:
                        ALOGW("[ConfigReader] mmtp subtype is not supported");
                        return false;
                }
                if (filterConfig.hasPid()) {
                    mmtp.mmtpPid = static_cast<int32_t>(filterConfig.getPid());
                    isMmtpSet = true;
                }
                if (isMmtpSet) {
                    settings.set<DemuxFilterSettings::Tag::mmtp>(mmtp);
                }
                break;
            }
            case FilterMainTypeEnum::IP: {
                ALOGW("[ConfigReader] filter main type is ip");
                type.mainType = DemuxFilterMainType::IP;
                DemuxIpFilterSettings ip;
                switch (subType) {
                    case FilterSubTypeEnum::UNDEFINED:
                        type.subType.set<DemuxFilterSubType::Tag::ipFilterType>(
                                DemuxIpFilterType::UNDEFINED);
                        break;
                    case FilterSubTypeEnum::SECTION:
                        type.subType.set<DemuxFilterSubType::Tag::ipFilterType>(
                                DemuxIpFilterType::SECTION);
                        ip.filterSettings.set<DemuxIpFilterSettingsFilterSettings::Tag::section>(
                                readSectionFilterSettings(filterConfig));
                        settings.set<DemuxFilterSettings::Tag::ip>(ip);
                        break;
                    case FilterSubTypeEnum::NTP:
                        type.subType.set<DemuxFilterSubType::Tag::ipFilterType>(
                                DemuxIpFilterType::NTP);
                        ip.filterSettings.set<DemuxIpFilterSettingsFilterSettings::Tag::noinit>(
                                true);
                        settings.set<DemuxFilterSettings::Tag::ip>(ip);
                        break;
                    case FilterSubTypeEnum::IP: {
                        type.subType.set<DemuxFilterSubType::Tag::ipFilterType>(
                                DemuxIpFilterType::IP);
                        ip.ipAddr = readIpAddress(filterConfig),
                        ip.filterSettings
                                .set<DemuxIpFilterSettingsFilterSettings::Tag::bPassthrough>(
                                        readPassthroughSettings(filterConfig));
                        settings.set<DemuxFilterSettings::Tag::ip>(ip);
                        break;
                    }
                    case FilterSubTypeEnum::IP_PAYLOAD:
                        type.subType.set<DemuxFilterSubType::Tag::ipFilterType>(
                                DemuxIpFilterType::IP_PAYLOAD);
                        ip.filterSettings.set<DemuxIpFilterSettingsFilterSettings::Tag::noinit>(
                                true);
                        settings.set<DemuxFilterSettings::Tag::ip>(ip);
                        break;
                    case FilterSubTypeEnum::PAYLOAD_THROUGH:
                        type.subType.set<DemuxFilterSubType::Tag::ipFilterType>(
                                DemuxIpFilterType::PAYLOAD_THROUGH);
                        ip.filterSettings.set<DemuxIpFilterSettingsFilterSettings::Tag::noinit>(
                                true);
                        settings.set<DemuxFilterSettings::Tag::ip>(ip);
                        break;
                    default:
                        ALOGW("[ConfigReader] mmtp subtype is not supported");
                        return false;
                }
                break;
            }
            default:
                // TODO: b/182519645 support all the filter configs
                ALOGW("[ConfigReader] filter main type is not supported in dynamic config");
                return false;
        }
        return true;
    }

    static DemuxIpAddress readIpAddress(Filter filterConfig) {
        DemuxIpAddress ipAddress;
        vector<uint8_t> data;
        if (!filterConfig.hasIpFilterConfig_optional()) {
            return ipAddress;
        }
        auto ipFilterConfig = filterConfig.getFirstIpFilterConfig_optional();
        if (ipFilterConfig->hasSrcPort()) {
            ipAddress.srcPort = ipFilterConfig->getSrcPort();
        }
        if (ipFilterConfig->hasDestPort()) {
            ipAddress.dstPort = ipFilterConfig->getDestPort();
        }
        if (ipFilterConfig->getFirstSrcIpAddress()->getIsIpV4()) {
            data.resize(4);
            memcpy(data.data(), ipFilterConfig->getFirstSrcIpAddress()->getIp().data(), 4);
            ipAddress.srcIpAddress.set<DemuxIpAddressIpAddress::Tag::v4>(data);
        } else {
            data.resize(6);
            memcpy(data.data(), ipFilterConfig->getFirstSrcIpAddress()->getIp().data(), 6);
            ipAddress.srcIpAddress.set<DemuxIpAddressIpAddress::Tag::v6>(data);
        }
        if (ipFilterConfig->getFirstDestIpAddress()->getIsIpV4()) {
            data.resize(4);
            memcpy(data.data(), ipFilterConfig->getFirstDestIpAddress()->getIp().data(), 4);
            ipAddress.dstIpAddress.set<DemuxIpAddressIpAddress::Tag::v4>(data);
        } else {
            data.resize(6);
            memcpy(data.data(), ipFilterConfig->getFirstDestIpAddress()->getIp().data(), 6);
            ipAddress.dstIpAddress.set<DemuxIpAddressIpAddress::Tag::v6>(data);
        }
        return ipAddress;
    }

    static bool readPassthroughSettings(Filter filterConfig) {
        if (!filterConfig.hasIpFilterConfig_optional()) {
            return false;
        }
        auto ipFilterConfig = filterConfig.getFirstIpFilterConfig_optional();
        if (ipFilterConfig->hasDataPassthrough()) {
            return ipFilterConfig->getDataPassthrough();
        }
        return false;
    }

    static DemuxFilterSectionSettings readSectionFilterSettings(Filter filterConfig) {
        DemuxFilterSectionSettings settings;
        if (!filterConfig.hasSectionFilterSettings_optional()) {
            return settings;
        }
        auto section = filterConfig.getFirstSectionFilterSettings_optional();
        settings.isCheckCrc = section->getIsCheckCrc();
        settings.isRepeat = section->getIsRepeat();
        settings.isRaw = section->getIsRaw();
        settings.bitWidthOfLengthField = section->getBitWidthOfLengthField();
        return settings;
    }

    static DemuxFilterAvSettings readAvFilterSettings(Filter filterConfig) {
        DemuxFilterAvSettings settings;
        if (!filterConfig.hasAvFilterSettings_optional()) {
            return settings;
        }
        auto av = filterConfig.getFirstAvFilterSettings_optional();
        settings.isPassthrough = av->getIsPassthrough();
        settings.isSecureMemory = av->getIsSecureMemory();
        return settings;
    }

    static DemuxFilterRecordSettings readRecordFilterSettings(Filter filterConfig) {
        DemuxFilterRecordSettings settings;
        if (!filterConfig.hasRecordFilterSettings_optional()) {
            return settings;
        }
        auto record = filterConfig.getFirstRecordFilterSettings_optional();
        settings.tsIndexMask = record->getTsIndexMask();
        settings.scIndexType = static_cast<DemuxRecordScIndexType>(record->getScIndexType());
        return settings;
    }

    static PlaybackSettings readPlaybackSettings(Dvr dvrConfig) {
        ALOGW("[ConfigReader] dvr type is playback");
        PlaybackSettings playbackSettings{
                .statusMask = static_cast<int8_t>(dvrConfig.getStatusMask()),
                .lowThreshold = static_cast<int64_t>(dvrConfig.getLowThreshold()),
                .highThreshold = static_cast<int64_t>(dvrConfig.getHighThreshold()),
                .dataFormat = static_cast<DataFormat>(dvrConfig.getDataFormat()),
                .packetSize = static_cast<int64_t>(dvrConfig.getPacketSize()),
        };
        return playbackSettings;
    }

    static RecordSettings readRecordSettings(Dvr dvrConfig) {
        ALOGW("[ConfigReader] dvr type is record");
        RecordSettings recordSettings{
                .statusMask = static_cast<int8_t>(dvrConfig.getStatusMask()),
                .lowThreshold = static_cast<int64_t>(dvrConfig.getLowThreshold()),
                .highThreshold = static_cast<int64_t>(dvrConfig.getHighThreshold()),
                .dataFormat = static_cast<DataFormat>(dvrConfig.getDataFormat()),
                .packetSize = static_cast<int64_t>(dvrConfig.getPacketSize()),
        };
        return recordSettings;
    }

    static void getCiCamInfo(Frontend feConfig, bool& canConnectToCiCam, int32_t& ciCamId,
                             int32_t& removePid) {
        if (!feConfig.hasConnectToCicamId()) {
            canConnectToCiCam = false;
            ciCamId = -1;
            removePid = -1;
            return;
        }
        canConnectToCiCam = true;
        ciCamId = static_cast<int32_t>(feConfig.getConnectToCicamId());
        removePid = static_cast<int32_t>(feConfig.getRemoveOutputPid());
    }
};