Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit dc239cbb authored by Amy Zhang's avatar Amy Zhang Committed by Automerger Merge Worker
Browse files

Merge "Connect FilterSettings between TunerFilter and FilterClient" into sc-dev am: 76629499

Original change: https://googleplex-android-review.googlesource.com/c/platform/frameworks/base/+/13459880

MUST ONLY BE SUBMITTED BY AUTOMERGER

Change-Id: Ib7d446bbd9e80f9d5b3f6f2ddc1c44fa1d127ff6
parents 8d56f11e 76629499
Loading
Loading
Loading
Loading
+308 −26
Original line number Diff line number Diff line
@@ -22,17 +22,24 @@

#include "FilterClient.h"

using ::aidl::android::media::tv::tuner::TunerFilterAvSettings;
using ::aidl::android::media::tv::tuner::TunerDemuxIpAddressSettings;
using ::aidl::android::media::tv::tuner::TunerFilterAlpConfiguration;
using ::aidl::android::media::tv::tuner::TunerFilterIpConfiguration;
using ::aidl::android::media::tv::tuner::TunerFilterMmtpConfiguration;
using ::aidl::android::media::tv::tuner::TunerFilterMonitorEvent;
using ::aidl::android::media::tv::tuner::TunerFilterScIndexMask;
using ::aidl::android::media::tv::tuner::TunerFilterSectionBits;
using ::aidl::android::media::tv::tuner::TunerFilterSectionCondition;
using ::aidl::android::media::tv::tuner::TunerFilterSectionTableInfo;
using ::aidl::android::media::tv::tuner::TunerFilterSharedHandleInfo;
using ::aidl::android::media::tv::tuner::TunerFilterTlvConfiguration;
using ::aidl::android::media::tv::tuner::TunerFilterTsConfiguration;

using ::android::hardware::tv::tuner::V1_0::DemuxQueueNotifyBits;
using ::android::hardware::tv::tuner::V1_0::DemuxFilterMainType;
using ::android::hardware::tv::tuner::V1_0::DemuxMmtpFilterType;
using ::android::hardware::tv::tuner::V1_0::DemuxTpid;
using ::android::hardware::tv::tuner::V1_0::DemuxQueueNotifyBits;
using ::android::hardware::tv::tuner::V1_0::DemuxStreamId;
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_1::ScramblingStatus;
@@ -318,42 +325,317 @@ Status TunerFilterCallback::onFilterEvent(const vector<TunerFilterEvent>& filter

TunerFilterConfiguration FilterClient::getAidlFilterSettings(DemuxFilterSettings configure) {
    TunerFilterConfiguration config;
    // TODO: complete filter setting conversion
    switch (configure.getDiscriminator()) {
        case DemuxFilterSettings::hidl_discriminator::ts: {
        case DemuxFilterSettings::hidl_discriminator::ts:
            return getAidlTsSettings(configure.ts());
        case DemuxFilterSettings::hidl_discriminator::mmtp:
            return getAidlMmtpSettings(configure.mmtp());
        case DemuxFilterSettings::hidl_discriminator::ip:
            return getAidlIpSettings(configure.ip());
        case DemuxFilterSettings::hidl_discriminator::tlv:
            return getAidlTlvSettings(configure.tlv());
        case DemuxFilterSettings::hidl_discriminator::alp:
            return getAidlAlpSettings(configure.alp());
        default:
            break;
    }
    ALOGE("Wrong DemuxFilterSettings union.");
    return config;
}

TunerFilterConfiguration FilterClient::getAidlTsSettings(DemuxTsFilterSettings ts) {
    TunerFilterConfiguration config;
    TunerFilterSettings filterSettings;
            switch (configure.ts().filterSettings.getDiscriminator()) {
    switch (ts.filterSettings.getDiscriminator()) {
        case DemuxTsFilterSettings::FilterSettings::hidl_discriminator::av: {
                    TunerFilterAvSettings av{
                        .isPassthrough = configure.ts().filterSettings.av().isPassthrough,
            filterSettings.set<TunerFilterSettings::av>(
                    getAidlAvSettings(ts.filterSettings.av()));
            break;
        }
        case DemuxTsFilterSettings::FilterSettings::hidl_discriminator::section: {
            filterSettings.set<TunerFilterSettings::section>(
                    getAidlSectionSettings(ts.filterSettings.section()));
            break;
        }
        case DemuxTsFilterSettings::FilterSettings::hidl_discriminator::pesData: {
            filterSettings.set<TunerFilterSettings::pesData>(
                    getAidlPesDataSettings(ts.filterSettings.pesData()));
            break;
        }
        case DemuxTsFilterSettings::FilterSettings::hidl_discriminator::record: {
            filterSettings.set<TunerFilterSettings::record>(
                    getAidlRecordSettings(ts.filterSettings.record()));
            break;
        }
        default:
            filterSettings.set<TunerFilterSettings::nothing>(true);
            break;
    }

    TunerFilterTsConfiguration aidlTs{
        .tpid = static_cast<char16_t>(ts.tpid),
        .filterSettings = filterSettings,
    };
                    filterSettings.set<TunerFilterSettings::av>(av);
    config.set<TunerFilterConfiguration::ts>(aidlTs);

    return config;
}

TunerFilterConfiguration FilterClient::getAidlMmtpSettings(DemuxMmtpFilterSettings mmtp) {
    TunerFilterConfiguration config;
    TunerFilterSettings filterSettings;
    switch (mmtp.filterSettings.getDiscriminator()) {
        case DemuxMmtpFilterSettings::FilterSettings::hidl_discriminator::av: {
            filterSettings.set<TunerFilterSettings::av>(
                    getAidlAvSettings(mmtp.filterSettings.av()));
            break;
        }
        case DemuxMmtpFilterSettings::FilterSettings::hidl_discriminator::section: {
            filterSettings.set<TunerFilterSettings::section>(
                    getAidlSectionSettings(mmtp.filterSettings.section()));
            break;
        }
        case DemuxMmtpFilterSettings::FilterSettings::hidl_discriminator::pesData: {
            filterSettings.set<TunerFilterSettings::pesData>(
                    getAidlPesDataSettings(mmtp.filterSettings.pesData()));
            break;
        }
        case DemuxMmtpFilterSettings::FilterSettings::hidl_discriminator::record: {
            filterSettings.set<TunerFilterSettings::record>(
                    getAidlRecordSettings(mmtp.filterSettings.record()));
            break;
        }
        case DemuxMmtpFilterSettings::FilterSettings::hidl_discriminator::download: {
            filterSettings.set<TunerFilterSettings::download>(
                    getAidlDownloadSettings(mmtp.filterSettings.download()));
            break;
        }
        default:
            filterSettings.set<TunerFilterSettings::nothing>(true);
            break;
    }

            TunerFilterTsConfiguration ts{
                .tpid = configure.ts().tpid,
    TunerFilterMmtpConfiguration aidlMmtp{
        .mmtpPid = static_cast<char16_t>(mmtp.mmtpPid),
        .filterSettings = filterSettings,
    };
            config.set<TunerFilterConfiguration::ts>(ts);
    config.set<TunerFilterConfiguration::mmtp>(aidlMmtp);

    return config;
}
        case DemuxFilterSettings::hidl_discriminator::mmtp:

TunerFilterConfiguration FilterClient::getAidlIpSettings(DemuxIpFilterSettings ip) {
    TunerFilterConfiguration config;
    TunerFilterSettings filterSettings;
    switch (ip.filterSettings.getDiscriminator()) {
        case DemuxIpFilterSettings::FilterSettings::hidl_discriminator::section: {
            filterSettings.set<TunerFilterSettings::section>(
                    getAidlSectionSettings(ip.filterSettings.section()));
            break;
        case DemuxFilterSettings::hidl_discriminator::ip:
        }
        case DemuxIpFilterSettings::FilterSettings::hidl_discriminator::bPassthrough: {
            filterSettings.set<TunerFilterSettings::isPassthrough>(
                    ip.filterSettings.bPassthrough());
            break;
        case DemuxFilterSettings::hidl_discriminator::tlv:
        }
        default:
            filterSettings.set<TunerFilterSettings::nothing>(true);
            break;
    }

    TunerDemuxIpAddressSettings ipAddr{
        .srcPort = static_cast<char16_t>(ip.ipAddr.srcPort),
        .dstPort = static_cast<char16_t>(ip.ipAddr.dstPort),
    };
    getAidlIpAddress(ip.ipAddr, ipAddr.srcIpAddress, ipAddr.dstIpAddress);

    TunerFilterIpConfiguration aidlIp{
        .ipAddr = ipAddr,
        .filterSettings = filterSettings,
    };
    config.set<TunerFilterConfiguration::ip>(aidlIp);

    return config;
}

void FilterClient::getAidlIpAddress(DemuxIpAddress ipAddr,
        TunerDemuxIpAddress& srcIpAddress, TunerDemuxIpAddress& dstIpAddress) {
    switch (ipAddr.srcIpAddress.getDiscriminator()) {
        case DemuxIpAddress::SrcIpAddress::hidl_discriminator::v4: {
            int size = ipAddr.srcIpAddress.v4().size();
            srcIpAddress.isIpV6 = false;
            srcIpAddress.addr.resize(ipAddr.srcIpAddress.v4().size());
            copy(&ipAddr.srcIpAddress.v4()[0], &ipAddr.srcIpAddress.v4()[size],
                    srcIpAddress.addr.begin());
            break;
        }
        case DemuxIpAddress::SrcIpAddress::hidl_discriminator::v6: {
            int size = ipAddr.srcIpAddress.v6().size();
            srcIpAddress.isIpV6 = true;
            srcIpAddress.addr.resize(size);
            copy(&ipAddr.srcIpAddress.v6()[0], &ipAddr.srcIpAddress.v6()[size],
                    srcIpAddress.addr.begin());
            break;
        }
        default:
            break;
    }
    switch (ipAddr.dstIpAddress.getDiscriminator()) {
        case DemuxIpAddress::DstIpAddress::hidl_discriminator::v4: {
            int size = ipAddr.dstIpAddress.v4().size();
            dstIpAddress.isIpV6 = false;
            dstIpAddress.addr.resize(size);
            copy(&ipAddr.dstIpAddress.v4()[0], &ipAddr.dstIpAddress.v4()[size],
                    dstIpAddress.addr.begin());
            break;
        }
        case DemuxIpAddress::DstIpAddress::hidl_discriminator::v6: {
            int size = ipAddr.dstIpAddress.v6().size();
            dstIpAddress.isIpV6 = true;
            dstIpAddress.addr.resize(size);
            copy(&ipAddr.dstIpAddress.v6()[0], &ipAddr.dstIpAddress.v6()[size],
                    dstIpAddress.addr.begin());
            break;
        }
        default:
            break;
    }
}

TunerFilterConfiguration FilterClient::getAidlTlvSettings(DemuxTlvFilterSettings tlv) {
    TunerFilterConfiguration config;
    TunerFilterSettings filterSettings;
    switch (tlv.filterSettings.getDiscriminator()) {
        case DemuxTlvFilterSettings::FilterSettings::hidl_discriminator::section: {
            filterSettings.set<TunerFilterSettings::section>(
                    getAidlSectionSettings(tlv.filterSettings.section()));
            break;
        }
        case DemuxTlvFilterSettings::FilterSettings::hidl_discriminator::bPassthrough: {
            filterSettings.set<TunerFilterSettings::isPassthrough>(
                    tlv.filterSettings.bPassthrough());
            break;
        }
        default:
            filterSettings.set<TunerFilterSettings::nothing>(true);
            break;
    }

    TunerFilterTlvConfiguration aidlTlv{
        .packetType = static_cast<int8_t>(tlv.packetType),
        .isCompressedIpPacket = tlv.isCompressedIpPacket,
        .filterSettings = filterSettings,
    };
    config.set<TunerFilterConfiguration::tlv>(aidlTlv);

    return config;
}

TunerFilterConfiguration FilterClient::getAidlAlpSettings(DemuxAlpFilterSettings alp) {
    TunerFilterConfiguration config;
    TunerFilterSettings filterSettings;
    switch (alp.filterSettings.getDiscriminator()) {
        case DemuxAlpFilterSettings::FilterSettings::hidl_discriminator::section: {
            filterSettings.set<TunerFilterSettings::section>(
                    getAidlSectionSettings(alp.filterSettings.section()));
            break;
        }
        default:
            filterSettings.set<TunerFilterSettings::nothing>(true);
            break;
    }

    TunerFilterAlpConfiguration aidlAlp{
        .packetType = static_cast<int8_t>(alp.packetType),
        .lengthType = static_cast<int8_t>(alp.lengthType),
        .filterSettings = filterSettings,
    };
    config.set<TunerFilterConfiguration::alp>(aidlAlp);

    return config;
}

TunerFilterAvSettings FilterClient::getAidlAvSettings(DemuxFilterAvSettings hidlAv) {
    TunerFilterAvSettings aidlAv{
        .isPassthrough = hidlAv.isPassthrough,
    };
    return aidlAv;
}

TunerFilterSectionSettings FilterClient::getAidlSectionSettings(
        DemuxFilterSectionSettings hidlSection) {
    TunerFilterSectionSettings aidlSection;

    switch (hidlSection.condition.getDiscriminator()) {
        case DemuxFilterSectionSettings::Condition::hidl_discriminator::sectionBits: {
            TunerFilterSectionBits sectionBits;
            auto hidlSectionBits = hidlSection.condition.sectionBits();
            sectionBits.filter.resize(hidlSectionBits.filter.size());
            sectionBits.mask.resize(hidlSectionBits.mask.size());
            sectionBits.mode.resize(hidlSectionBits.mode.size());
            copy(hidlSectionBits.filter.begin(), hidlSectionBits.filter.end(),
                    hidlSectionBits.filter.begin());
            copy(hidlSectionBits.mask.begin(), hidlSectionBits.mask.end(),
                    hidlSectionBits.mask.begin());
            copy(hidlSectionBits.mode.begin(), hidlSectionBits.mode.end(),
                    hidlSectionBits.mode.begin());
            aidlSection.condition.set<TunerFilterSectionCondition::sectionBits>(sectionBits);
            break;
        }
        case DemuxFilterSectionSettings::Condition::hidl_discriminator::tableInfo: {
            TunerFilterSectionTableInfo tableInfo{
                .tableId = static_cast<char16_t>(hidlSection.condition.tableInfo().tableId),
                .version = static_cast<char16_t>(hidlSection.condition.tableInfo().version),
            };
            aidlSection.condition.set<TunerFilterSectionCondition::tableInfo>(tableInfo);
            break;
        }
    }
    aidlSection.isCheckCrc = hidlSection.isCheckCrc;
    aidlSection.isRepeat = hidlSection.isRepeat;
    aidlSection.isRaw = hidlSection.isRaw;
    return aidlSection;
}

TunerFilterPesDataSettings FilterClient::getAidlPesDataSettings(
        DemuxFilterPesDataSettings hidlPesData) {
    TunerFilterPesDataSettings aidlPesData{
        .streamId = static_cast<char16_t>(hidlPesData.streamId),
        .isRaw = hidlPesData.isRaw,
    };
    return aidlPesData;
}

TunerFilterRecordSettings FilterClient::getAidlRecordSettings(
        DemuxFilterRecordSettings hidlRecord) {
    TunerFilterScIndexMask mask;
    switch (hidlRecord.scIndexMask.getDiscriminator()) {
        case DemuxFilterRecordSettings::ScIndexMask::hidl_discriminator::sc: {
            mask.set<TunerFilterScIndexMask::sc>(hidlRecord.scIndexMask.sc());
            break;
        }
        case DemuxFilterRecordSettings::ScIndexMask::hidl_discriminator::scHevc: {
            mask.set<TunerFilterScIndexMask::scHevc>(hidlRecord.scIndexMask.scHevc());
            break;
        }
        default:
            break;
    }
    TunerFilterRecordSettings aidlRecord{
        .tsIndexMask = static_cast<int32_t>(hidlRecord.tsIndexMask),
        .scIndexType = static_cast<int32_t>(hidlRecord.scIndexType),
        .scIndexMask = mask,
    };
    return aidlRecord;
}

TunerFilterDownloadSettings FilterClient::getAidlDownloadSettings(
        DemuxFilterDownloadSettings hidlDownload) {
    TunerFilterDownloadSettings aidlDownload{
        .downloadId = static_cast<int32_t>(hidlDownload.downloadId),
    };
    return aidlDownload;
}

void TunerFilterCallback::getHidlFilterEvent(const vector<TunerFilterEvent>& filterEvents,
        DemuxFilterEvent& event, DemuxFilterEventExt& eventExt) {
+32 −0
Original line number Diff line number Diff line
@@ -33,8 +33,14 @@
using Status = ::ndk::ScopedAStatus;
using ::aidl::android::media::tv::tuner::BnTunerFilterCallback;
using ::aidl::android::media::tv::tuner::ITunerFilter;
using ::aidl::android::media::tv::tuner::TunerDemuxIpAddress;
using ::aidl::android::media::tv::tuner::TunerFilterAvSettings;
using ::aidl::android::media::tv::tuner::TunerFilterConfiguration;
using ::aidl::android::media::tv::tuner::TunerFilterDownloadSettings;
using ::aidl::android::media::tv::tuner::TunerFilterEvent;
using ::aidl::android::media::tv::tuner::TunerFilterPesDataSettings;
using ::aidl::android::media::tv::tuner::TunerFilterRecordSettings;
using ::aidl::android::media::tv::tuner::TunerFilterSectionSettings;
using ::aidl::android::media::tv::tuner::TunerFilterSettings;

using ::android::hardware::EventFlag;
@@ -43,8 +49,19 @@ using ::android::hardware::MQDescriptorSync;
using ::android::hardware::Return;
using ::android::hardware::Void;
using ::android::hardware::hidl_handle;
using ::android::hardware::tv::tuner::V1_0::DemuxAlpFilterSettings;
using ::android::hardware::tv::tuner::V1_0::DemuxMmtpFilterSettings;
using ::android::hardware::tv::tuner::V1_0::DemuxFilterAvSettings;
using ::android::hardware::tv::tuner::V1_0::DemuxFilterDownloadSettings;
using ::android::hardware::tv::tuner::V1_0::DemuxFilterPesDataSettings;
using ::android::hardware::tv::tuner::V1_0::DemuxFilterRecordSettings;
using ::android::hardware::tv::tuner::V1_0::DemuxFilterSectionSettings;
using ::android::hardware::tv::tuner::V1_0::DemuxFilterSettings;
using ::android::hardware::tv::tuner::V1_0::DemuxFilterType;
using ::android::hardware::tv::tuner::V1_0::DemuxIpAddress;
using ::android::hardware::tv::tuner::V1_0::DemuxIpFilterSettings;
using ::android::hardware::tv::tuner::V1_0::DemuxTlvFilterSettings;
using ::android::hardware::tv::tuner::V1_0::DemuxTsFilterSettings;
using ::android::hardware::tv::tuner::V1_0::IFilter;
using ::android::hardware::tv::tuner::V1_0::Result;
using ::android::hardware::tv::tuner::V1_1::AvStreamType;
@@ -201,6 +218,21 @@ public:

private:
    TunerFilterConfiguration getAidlFilterSettings(DemuxFilterSettings configure);

    TunerFilterConfiguration getAidlTsSettings(DemuxTsFilterSettings configure);
    TunerFilterConfiguration getAidlMmtpSettings(DemuxMmtpFilterSettings mmtp);
    TunerFilterConfiguration getAidlIpSettings(DemuxIpFilterSettings ip);
    TunerFilterConfiguration getAidlTlvSettings(DemuxTlvFilterSettings tlv);
    TunerFilterConfiguration getAidlAlpSettings(DemuxAlpFilterSettings alp);

    TunerFilterAvSettings getAidlAvSettings(DemuxFilterAvSettings hidlAv);
    TunerFilterSectionSettings getAidlSectionSettings(DemuxFilterSectionSettings hidlSection);
    TunerFilterPesDataSettings getAidlPesDataSettings(DemuxFilterPesDataSettings hidlPesData);
    TunerFilterRecordSettings getAidlRecordSettings(DemuxFilterRecordSettings hidlRecord);
    TunerFilterDownloadSettings getAidlDownloadSettings(DemuxFilterDownloadSettings hidlDownload);

    void getAidlIpAddress(DemuxIpAddress ipAddr,
            TunerDemuxIpAddress& srcIpAddress, TunerDemuxIpAddress& dstIpAddress);
    Result getFilterMq();
    int copyData(uint8_t* buffer, int size);
    void checkIsMediaFilter(DemuxFilterType type);