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

Commit 634fd567 authored by Amy Zhang's avatar Amy Zhang Committed by Android (Google) Code Review
Browse files

Merge "Complete TunerFilterSettings aidl interfaces and TunerFilter implementations" into sc-dev

parents e593965d db01aee8

services/tuner/TunerFilter.cpp

+325 −66
Original line number Original line Diff line number Diff line
@@ -18,17 +18,24 @@ 




#include "TunerFilter.h"

#include "TunerFilter.h"





using ::aidl::android::media::tv::tuner::TunerFilterSectionCondition;



using ::android::hardware::hidl_handle;

using ::android::hardware::hidl_handle;

using ::android::hardware::tv::tuner::V1_0::DemuxAlpLengthType;

using ::android::hardware::tv::tuner::V1_0::DemuxFilterMainType;

using ::android::hardware::tv::tuner::V1_0::DemuxFilterMainType;

using ::android::hardware::tv::tuner::V1_0::DemuxFilterSettings;

using ::android::hardware::tv::tuner::V1_0::DemuxIpAddress;

using ::android::hardware::tv::tuner::V1_0::DemuxMmtpFilterType;

using ::android::hardware::tv::tuner::V1_0::DemuxMmtpFilterType;

using ::android::hardware::tv::tuner::V1_0::DemuxTsFilterSettings;

using ::android::hardware::tv::tuner::V1_0::DemuxMmtpPid;

using ::android::hardware::tv::tuner::V1_0::DemuxRecordScIndexType;

using ::android::hardware::tv::tuner::V1_0::DemuxStreamId;

using ::android::hardware::tv::tuner::V1_0::DemuxTsFilterType;

using ::android::hardware::tv::tuner::V1_0::DemuxTsFilterType;

using ::android::hardware::tv::tuner::V1_0::Result;

using ::android::hardware::tv::tuner::V1_0::Result;

using ::android::hardware::tv::tuner::V1_1::Constant;

using ::android::hardware::tv::tuner::V1_1::Constant;





namespace android {

namespace android {





using namespace std;



TunerFilter::TunerFilter(

TunerFilter::TunerFilter(

        sp<IFilter> filter, sp<IFilterCallback> callback) {

        sp<IFilter> filter, sp<IFilterCallback> callback) {

    mFilter = filter;

    mFilter = filter;
@@ -42,13 +49,6 @@ TunerFilter::~TunerFilter() { 
    mFilterCallback = nullptr;

    mFilterCallback = nullptr;

}

}





DemuxFilterAvSettings TunerFilter::getAvSettings(const TunerFilterSettings& settings) {

    DemuxFilterAvSettings av {

        .isPassthrough = settings.get<TunerFilterSettings::av>().isPassthrough,

    };

    return av;

}



Status TunerFilter::getId(int32_t* _aidl_return) {

Status TunerFilter::getId(int32_t* _aidl_return) {

    if (mFilter == nullptr) {

    if (mFilter == nullptr) {

        ALOGE("IFilter is not initialized");

        ALOGE("IFilter is not initialized");
@@ -91,32 +91,291 @@ Status TunerFilter::configure(const TunerFilterConfiguration& config) { 
        return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));

        return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));

    }

    }





    // TODO: more filter types.

    DemuxFilterSettings settings;

    TunerFilterSettings tunerSettings;

    DemuxFilterSettings halSettings;

    switch (config.getTag()) {

    switch (config.getTag()) {

        case TunerFilterConfiguration::ts: {

        case TunerFilterConfiguration::ts: {

            uint16_t tpid = static_cast<uint16_t>(config.get<TunerFilterConfiguration::ts>().tpid);

            getHidlTsSettings(config, settings);

            tunerSettings = config.get<TunerFilterConfiguration::ts>().filterSettings;

            break;

        }

        case TunerFilterConfiguration::mmtp: {

            getHidlMmtpSettings(config, settings);

            break;

        }

        case TunerFilterConfiguration::ip: {

            getHidlIpSettings(config, settings);

            break;

        }

        case TunerFilterConfiguration::tlv: {

            getHidlTlvSettings(config, settings);

            break;

        }

        case TunerFilterConfiguration::alp: {

            getHidlAlpSettings(config, settings);

            break;

        }

    }



    Result res = mFilter->configure(settings);

    if (res != Result::SUCCESS) {

        return Status::fromServiceSpecificError(static_cast<int32_t>(res));

    }

    return Status::ok();

}



void TunerFilter::getHidlTsSettings(

        const TunerFilterConfiguration& config, DemuxFilterSettings& settings) {

    auto tsConf = config.get<TunerFilterConfiguration::ts>();

    DemuxTsFilterSettings ts{

    DemuxTsFilterSettings ts{

                .tpid = tpid,

        .tpid = static_cast<uint16_t>(tsConf.tpid),

    };

    };





    TunerFilterSettings tunerSettings = tsConf.filterSettings;

    switch (tunerSettings.getTag()) {

    switch (tunerSettings.getTag()) {

        case TunerFilterSettings::av: {

        case TunerFilterSettings::av: {

            ts.filterSettings.av(getAvSettings(tunerSettings));

            ts.filterSettings.av(getAvSettings(tunerSettings));

            break;

            break;

        }

        }

        case TunerFilterSettings::section: {

            ts.filterSettings.section(getSectionSettings(tunerSettings));

            break;

        }

        }

            halSettings.ts(ts);

        case TunerFilterSettings::pesData: {

            ts.filterSettings.pesData(getPesDataSettings(tunerSettings));

            break;

            break;

        }

        }

        case TunerFilterSettings::record: {

            ts.filterSettings.record(getRecordSettings(tunerSettings));

            break;

        }

        }

    Result res = mFilter->configure(halSettings);

        default: {

    if (res != Result::SUCCESS) {

            ts.filterSettings.noinit();

        return Status::fromServiceSpecificError(static_cast<int32_t>(res));

            break;

        }

        }

    return Status::ok();

    }

    settings.ts(ts);

}



void TunerFilter::getHidlMmtpSettings(

        const TunerFilterConfiguration& config, DemuxFilterSettings& settings) {

    auto mmtpConf = config.get<TunerFilterConfiguration::mmtp>();

    DemuxMmtpFilterSettings mmtp{

        .mmtpPid = static_cast<DemuxMmtpPid>(mmtpConf.mmtpPid),

    };



    TunerFilterSettings tunerSettings = mmtpConf.filterSettings;

    switch (tunerSettings.getTag()) {

        case TunerFilterSettings::av: {

            mmtp.filterSettings.av(getAvSettings(tunerSettings));

            break;

        }

        case TunerFilterSettings::section: {

            mmtp.filterSettings.section(getSectionSettings(tunerSettings));

            break;

        }

        case TunerFilterSettings::pesData: {

            mmtp.filterSettings.pesData(getPesDataSettings(tunerSettings));

            break;

        }

        case TunerFilterSettings::record: {

            mmtp.filterSettings.record(getRecordSettings(tunerSettings));

            break;

        }

        case TunerFilterSettings::download: {

            mmtp.filterSettings.download(getDownloadSettings(tunerSettings));

            break;

        }

        default: {

            mmtp.filterSettings.noinit();

            break;

        }

    }

    settings.mmtp(mmtp);

}



void TunerFilter::getHidlIpSettings(

        const TunerFilterConfiguration& config, DemuxFilterSettings& settings) {

    auto ipConf = config.get<TunerFilterConfiguration::ip>();

    DemuxIpAddress ipAddr{

        .srcPort = static_cast<uint16_t>(ipConf.ipAddr.srcPort),

        .dstPort = static_cast<uint16_t>(ipConf.ipAddr.dstPort),

    };

    ipConf.ipAddr.srcIpAddress.isIpV6

            ? ipAddr.srcIpAddress.v6(getIpV6Address(ipConf.ipAddr.srcIpAddress))

            : ipAddr.srcIpAddress.v4(getIpV4Address(ipConf.ipAddr.srcIpAddress));

    ipConf.ipAddr.dstIpAddress.isIpV6

            ? ipAddr.dstIpAddress.v6(getIpV6Address(ipConf.ipAddr.dstIpAddress))

            : ipAddr.dstIpAddress.v4(getIpV4Address(ipConf.ipAddr.dstIpAddress));

    DemuxIpFilterSettings ip{

        .ipAddr = ipAddr,

    };



    TunerFilterSettings tunerSettings = ipConf.filterSettings;

    switch (tunerSettings.getTag()) {

        case TunerFilterSettings::section: {

            ip.filterSettings.section(getSectionSettings(tunerSettings));

            break;

        }

        case TunerFilterSettings::isPassthrough: {

            ip.filterSettings.bPassthrough(tunerSettings.isPassthrough);

            break;

        }

        default: {

            ip.filterSettings.noinit();

            break;

        }

    }

    settings.ip(ip);

}



hidl_array<uint8_t, IP_V6_LENGTH> TunerFilter::getIpV6Address(TunerDemuxIpAddress addr) {

    hidl_array<uint8_t, IP_V6_LENGTH> ip = {0};

    if (addr.addr.size() != IP_V6_LENGTH) {

        return ip;

    }

    copy(addr.addr.begin(), addr.addr.end(), ip.data());

    return ip;

}



hidl_array<uint8_t, IP_V4_LENGTH> TunerFilter::getIpV4Address(TunerDemuxIpAddress addr) {

    hidl_array<uint8_t, IP_V4_LENGTH> ip = {0};

    if (addr.addr.size() != IP_V4_LENGTH) {

        return ip;

    }

    copy(addr.addr.begin(), addr.addr.end(), ip.data());

    return ip;

}



void TunerFilter::getHidlTlvSettings(

        const TunerFilterConfiguration& config, DemuxFilterSettings& settings) {

    auto tlvConf = config.get<TunerFilterConfiguration::tlv>();

    DemuxTlvFilterSettings tlv{

        .packetType = static_cast<uint8_t>(tlvConf.packetType),

        .isCompressedIpPacket = tlvConf.isCompressedIpPacket,

    };



    TunerFilterSettings tunerSettings = tlvConf.filterSettings;

    switch (tunerSettings.getTag()) {

        case TunerFilterSettings::section: {

            tlv.filterSettings.section(getSectionSettings(tunerSettings));

            break;

        }

        case TunerFilterSettings::isPassthrough: {

            tlv.filterSettings.bPassthrough(tunerSettings.isPassthrough);

            break;

        }

        default: {

            tlv.filterSettings.noinit();

            break;

        }

    }

    settings.tlv(tlv);

}



void TunerFilter::getHidlAlpSettings(

        const TunerFilterConfiguration& config, DemuxFilterSettings& settings) {

    auto alpConf = config.get<TunerFilterConfiguration::alp>();

    DemuxAlpFilterSettings alp{

        .packetType = static_cast<uint8_t>(alpConf.packetType),

        .lengthType = static_cast<DemuxAlpLengthType>(alpConf.lengthType),

    };



    TunerFilterSettings tunerSettings = alpConf.filterSettings;

    switch (tunerSettings.getTag()) {

        case TunerFilterSettings::section: {

            alp.filterSettings.section(getSectionSettings(tunerSettings));

            break;

        }

        default: {

            alp.filterSettings.noinit();

            break;

        }

    }

    settings.alp(alp);

}



DemuxFilterAvSettings TunerFilter::getAvSettings(const TunerFilterSettings& settings) {

    DemuxFilterAvSettings av {

        .isPassthrough = settings.get<TunerFilterSettings::av>().isPassthrough,

    };

    return av;

}



DemuxFilterSectionSettings TunerFilter::getSectionSettings(const TunerFilterSettings& settings) {

    auto s = settings.get<TunerFilterSettings::section>();

    DemuxFilterSectionSettings section{

        .isCheckCrc = s.isCheckCrc,

        .isRepeat = s.isRepeat,

        .isRaw = s.isRaw,

    };



    switch (s.condition.getTag()) {

        case TunerFilterSectionCondition::sectionBits: {

            auto sectionBits = s.condition.get<TunerFilterSectionCondition::sectionBits>();

            vector<uint8_t> filter(sectionBits.filter.size());

            vector<uint8_t> mask(sectionBits.mask.size());

            vector<uint8_t> mode(sectionBits.mode.size());

            copy(sectionBits.filter.begin(), sectionBits.filter.end(), filter.begin());

            copy(sectionBits.mask.begin(), sectionBits.mask.end(), mask.begin());

            copy(sectionBits.mode.begin(), sectionBits.mode.end(), mode.begin());

            section.condition.sectionBits({

                .filter = filter,

                .mask = mask,

                .mode = mode,

            });

            break;

        }

        case TunerFilterSectionCondition::tableInfo: {

            auto tableInfo = s.condition.get<TunerFilterSectionCondition::tableInfo>();

            section.condition.tableInfo({

                .tableId = static_cast<uint16_t>(tableInfo.tableId),

                .version = static_cast<uint16_t>(tableInfo.version),

            });

            break;

        }

        default: {

            break;

        }

    }

    return section;

}



DemuxFilterPesDataSettings TunerFilter::getPesDataSettings(const TunerFilterSettings& settings) {

    DemuxFilterPesDataSettings pes{

        .streamId = static_cast<DemuxStreamId>(

                settings.get<TunerFilterSettings::pesData>().streamId),

        .isRaw = settings.get<TunerFilterSettings::pesData>().isRaw,

    };

    return pes;

}



DemuxFilterRecordSettings TunerFilter::getRecordSettings(const TunerFilterSettings& settings) {

    auto r = settings.get<TunerFilterSettings::record>();

    DemuxFilterRecordSettings record{

        .tsIndexMask = static_cast<uint32_t>(r.tsIndexMask),

        .scIndexType = static_cast<DemuxRecordScIndexType>(r.scIndexType),

    };



    switch (r.scIndexMask.getTag()) {

        case TunerFilterScIndexMask::sc: {

            record.scIndexMask.sc(static_cast<uint32_t>(

                    r.scIndexMask.get<TunerFilterScIndexMask::sc>()));

            break;

        }

        case TunerFilterScIndexMask::scHevc: {

            record.scIndexMask.scHevc(static_cast<uint32_t>(

                    r.scIndexMask.get<TunerFilterScIndexMask::scHevc>()));

            break;

        }

    }

    return record;

}



DemuxFilterDownloadSettings TunerFilter::getDownloadSettings(const TunerFilterSettings& settings) {

    DemuxFilterDownloadSettings download {

        .downloadId = static_cast<uint32_t>(

                settings.get<TunerFilterSettings::download>().downloadId),

    };

    return download;

}

}





Status TunerFilter::getAvSharedHandleInfo(TunerFilterSharedHandleInfo* _aidl_return) {

Status TunerFilter::getAvSharedHandleInfo(TunerFilterSharedHandleInfo* _aidl_return) {
@@ -133,7 +392,7 @@ Status TunerFilter::getAvSharedHandleInfo(TunerFilterSharedHandleInfo* _aidl_ret 
                .handle = dupToAidl(hidl_handle(avMemory.getNativeHandle())),

                .handle = dupToAidl(hidl_handle(avMemory.getNativeHandle())),

                .size = static_cast<int64_t>(avMemSize),

                .size = static_cast<int64_t>(avMemSize),

            };

            };

            *_aidl_return = std::move(info);

            *_aidl_return = move(info);

        } else {

        } else {

            _aidl_return = NULL;

            _aidl_return = NULL;

        }

        }
@@ -219,7 +478,7 @@ Return<void> TunerFilter::FilterCallback::onFilterStatus(DemuxFilterStatus statu 
}

}





Return<void> TunerFilter::FilterCallback::onFilterEvent(const DemuxFilterEvent& filterEvent) {

Return<void> TunerFilter::FilterCallback::onFilterEvent(const DemuxFilterEvent& filterEvent) {

    std::vector<DemuxFilterEventExt::Event> emptyEventsExt;

    vector<DemuxFilterEventExt::Event> emptyEventsExt;

    DemuxFilterEventExt emptyFilterEventExt {

    DemuxFilterEventExt emptyFilterEventExt {

            .events = emptyEventsExt,

            .events = emptyEventsExt,

    };

    };
@@ -230,9 +489,9 @@ Return<void> TunerFilter::FilterCallback::onFilterEvent(const DemuxFilterEvent& 
Return<void> TunerFilter::FilterCallback::onFilterEvent_1_1(const DemuxFilterEvent& filterEvent,

Return<void> TunerFilter::FilterCallback::onFilterEvent_1_1(const DemuxFilterEvent& filterEvent,

        const DemuxFilterEventExt& filterEventExt) {

        const DemuxFilterEventExt& filterEventExt) {

    if (mTunerFilterCallback != NULL) {

    if (mTunerFilterCallback != NULL) {

        std::vector<DemuxFilterEvent::Event> events = filterEvent.events;

        vector<DemuxFilterEvent::Event> events = filterEvent.events;

        std::vector<DemuxFilterEventExt::Event> eventsExt = filterEventExt.events;

        vector<DemuxFilterEventExt::Event> eventsExt = filterEventExt.events;

        std::vector<TunerFilterEvent> tunerEvent;

        vector<TunerFilterEvent> tunerEvent;





        getAidlFilterEvent(events, eventsExt, tunerEvent);

        getAidlFilterEvent(events, eventsExt, tunerEvent);

        mTunerFilterCallback->onFilterEvent(tunerEvent);

        mTunerFilterCallback->onFilterEvent(tunerEvent);
@@ -242,9 +501,9 @@ Return<void> TunerFilter::FilterCallback::onFilterEvent_1_1(const DemuxFilterEve 




/////////////// FilterCallback Helper Methods ///////////////////////

/////////////// FilterCallback Helper Methods ///////////////////////





void TunerFilter::FilterCallback::getAidlFilterEvent(std::vector<DemuxFilterEvent::Event>& events,

void TunerFilter::FilterCallback::getAidlFilterEvent(vector<DemuxFilterEvent::Event>& events,

        std::vector<DemuxFilterEventExt::Event>& eventsExt,

        vector<DemuxFilterEventExt::Event>& eventsExt,

        std::vector<TunerFilterEvent>& tunerEvent) {

        vector<TunerFilterEvent>& tunerEvent) {

    if (events.empty() && !eventsExt.empty()) {

    if (events.empty() && !eventsExt.empty()) {

        auto eventExt = eventsExt[0];

        auto eventExt = eventsExt[0];

        switch (eventExt.getDiscriminator()) {

        switch (eventExt.getDiscriminator()) {
@@ -305,7 +564,7 @@ void TunerFilter::FilterCallback::getAidlFilterEvent(std::vector<DemuxFilterEven 
}

}





void TunerFilter::FilterCallback::getMediaEvent(

void TunerFilter::FilterCallback::getMediaEvent(

        std::vector<DemuxFilterEvent::Event>& events, std::vector<TunerFilterEvent>& res) {

        vector<DemuxFilterEvent::Event>& events, vector<TunerFilterEvent>& res) {

    for (DemuxFilterEvent::Event e : events) {

    for (DemuxFilterEvent::Event e : events) {

        DemuxFilterMediaEvent mediaEvent = e.media();

        DemuxFilterMediaEvent mediaEvent = e.media();

        TunerFilterMediaEvent tunerMedia;

        TunerFilterMediaEvent tunerMedia;
@@ -346,13 +605,13 @@ void TunerFilter::FilterCallback::getMediaEvent( 
        }

        }





        TunerFilterEvent tunerEvent;

        TunerFilterEvent tunerEvent;

        tunerEvent.set<TunerFilterEvent::media>(std::move(tunerMedia));

        tunerEvent.set<TunerFilterEvent::media>(move(tunerMedia));

        res.push_back(std::move(tunerEvent));

        res.push_back(move(tunerEvent));

    }

    }

}

}





void TunerFilter::FilterCallback::getSectionEvent(

void TunerFilter::FilterCallback::getSectionEvent(

        std::vector<DemuxFilterEvent::Event>& events, std::vector<TunerFilterEvent>& res) {

        vector<DemuxFilterEvent::Event>& events, vector<TunerFilterEvent>& res) {

    for (DemuxFilterEvent::Event e : events) {

    for (DemuxFilterEvent::Event e : events) {

        DemuxFilterSectionEvent sectionEvent = e.section();

        DemuxFilterSectionEvent sectionEvent = e.section();

        TunerFilterSectionEvent tunerSection;

        TunerFilterSectionEvent tunerSection;
@@ -363,13 +622,13 @@ void TunerFilter::FilterCallback::getSectionEvent( 
        tunerSection.dataLength = static_cast<char>(sectionEvent.dataLength);

        tunerSection.dataLength = static_cast<char>(sectionEvent.dataLength);





        TunerFilterEvent tunerEvent;

        TunerFilterEvent tunerEvent;

        tunerEvent.set<TunerFilterEvent::section>(std::move(tunerSection));

        tunerEvent.set<TunerFilterEvent::section>(move(tunerSection));

        res.push_back(std::move(tunerEvent));

        res.push_back(move(tunerEvent));

    }

    }

}

}





void TunerFilter::FilterCallback::getPesEvent(

void TunerFilter::FilterCallback::getPesEvent(

        std::vector<DemuxFilterEvent::Event>& events, std::vector<TunerFilterEvent>& res) {

        vector<DemuxFilterEvent::Event>& events, vector<TunerFilterEvent>& res) {

    for (DemuxFilterEvent::Event e : events) {

    for (DemuxFilterEvent::Event e : events) {

        DemuxFilterPesEvent pesEvent = e.pes();

        DemuxFilterPesEvent pesEvent = e.pes();

        TunerFilterPesEvent tunerPes;

        TunerFilterPesEvent tunerPes;
@@ -379,13 +638,13 @@ void TunerFilter::FilterCallback::getPesEvent( 
        tunerPes.mpuSequenceNumber = static_cast<int>(pesEvent.mpuSequenceNumber);

        tunerPes.mpuSequenceNumber = static_cast<int>(pesEvent.mpuSequenceNumber);





        TunerFilterEvent tunerEvent;

        TunerFilterEvent tunerEvent;

        tunerEvent.set<TunerFilterEvent::pes>(std::move(tunerPes));

        tunerEvent.set<TunerFilterEvent::pes>(move(tunerPes));

        res.push_back(std::move(tunerEvent));

        res.push_back(move(tunerEvent));

    }

    }

}

}





void TunerFilter::FilterCallback::getTsRecordEvent(std::vector<DemuxFilterEvent::Event>& events,

void TunerFilter::FilterCallback::getTsRecordEvent(vector<DemuxFilterEvent::Event>& events,

        std::vector<DemuxFilterEventExt::Event>& eventsExt, std::vector<TunerFilterEvent>& res) {

        vector<DemuxFilterEventExt::Event>& eventsExt, vector<TunerFilterEvent>& res) {

    for (int i = 0; i < events.size(); i++) {

    for (int i = 0; i < events.size(); i++) {

        TunerFilterTsRecordEvent tunerTsRecord;

        TunerFilterTsRecordEvent tunerTsRecord;

        DemuxFilterTsRecordEvent tsRecordEvent = events[i].tsRecord();

        DemuxFilterTsRecordEvent tsRecordEvent = events[i].tsRecord();
@@ -421,13 +680,13 @@ void TunerFilter::FilterCallback::getTsRecordEvent(std::vector<DemuxFilterEvent: 
        }

        }





        TunerFilterEvent tunerEvent;

        TunerFilterEvent tunerEvent;

        tunerEvent.set<TunerFilterEvent::tsRecord>(std::move(tunerTsRecord));

        tunerEvent.set<TunerFilterEvent::tsRecord>(move(tunerTsRecord));

        res.push_back(std::move(tunerEvent));

        res.push_back(move(tunerEvent));

    }

    }

}

}





void TunerFilter::FilterCallback::getMmtpRecordEvent(std::vector<DemuxFilterEvent::Event>& events,

void TunerFilter::FilterCallback::getMmtpRecordEvent(vector<DemuxFilterEvent::Event>& events,

        std::vector<DemuxFilterEventExt::Event>& eventsExt, std::vector<TunerFilterEvent>& res) {

        vector<DemuxFilterEventExt::Event>& eventsExt, vector<TunerFilterEvent>& res) {

    for (int i = 0; i < events.size(); i++) {

    for (int i = 0; i < events.size(); i++) {

        TunerFilterMmtpRecordEvent tunerMmtpRecord;

        TunerFilterMmtpRecordEvent tunerMmtpRecord;

        DemuxFilterMmtpRecordEvent mmtpRecordEvent = events[i].mmtpRecord();

        DemuxFilterMmtpRecordEvent mmtpRecordEvent = events[i].mmtpRecord();
@@ -449,13 +708,13 @@ void TunerFilter::FilterCallback::getMmtpRecordEvent(std::vector<DemuxFilterEven 
        }

        }





        TunerFilterEvent tunerEvent;

        TunerFilterEvent tunerEvent;

        tunerEvent.set<TunerFilterEvent::mmtpRecord>(std::move(tunerMmtpRecord));

        tunerEvent.set<TunerFilterEvent::mmtpRecord>(move(tunerMmtpRecord));

        res.push_back(std::move(tunerEvent));

        res.push_back(move(tunerEvent));

    }

    }

}

}





void TunerFilter::FilterCallback::getDownloadEvent(

void TunerFilter::FilterCallback::getDownloadEvent(

        std::vector<DemuxFilterEvent::Event>& events, std::vector<TunerFilterEvent>& res) {

        vector<DemuxFilterEvent::Event>& events, vector<TunerFilterEvent>& res) {

    for (DemuxFilterEvent::Event e : events) {

    for (DemuxFilterEvent::Event e : events) {

        DemuxFilterDownloadEvent downloadEvent = e.download();

        DemuxFilterDownloadEvent downloadEvent = e.download();

        TunerFilterDownloadEvent tunerDownload;

        TunerFilterDownloadEvent tunerDownload;
@@ -467,13 +726,13 @@ void TunerFilter::FilterCallback::getDownloadEvent( 
        tunerDownload.dataLength = static_cast<char>(downloadEvent.dataLength);

        tunerDownload.dataLength = static_cast<char>(downloadEvent.dataLength);





        TunerFilterEvent tunerEvent;

        TunerFilterEvent tunerEvent;

        tunerEvent.set<TunerFilterEvent::download>(std::move(tunerDownload));

        tunerEvent.set<TunerFilterEvent::download>(move(tunerDownload));

        res.push_back(std::move(tunerEvent));

        res.push_back(move(tunerEvent));

    }

    }

}

}





void TunerFilter::FilterCallback::getIpPayloadEvent(

void TunerFilter::FilterCallback::getIpPayloadEvent(

        std::vector<DemuxFilterEvent::Event>& events, std::vector<TunerFilterEvent>& res) {

        vector<DemuxFilterEvent::Event>& events, vector<TunerFilterEvent>& res) {

    for (DemuxFilterEvent::Event e : events) {

    for (DemuxFilterEvent::Event e : events) {

        DemuxFilterIpPayloadEvent ipPayloadEvent = e.ipPayload();

        DemuxFilterIpPayloadEvent ipPayloadEvent = e.ipPayload();

        TunerFilterIpPayloadEvent tunerIpPayload;

        TunerFilterIpPayloadEvent tunerIpPayload;
@@ -481,31 +740,31 @@ void TunerFilter::FilterCallback::getIpPayloadEvent( 
        tunerIpPayload.dataLength = static_cast<char>(ipPayloadEvent.dataLength);

        tunerIpPayload.dataLength = static_cast<char>(ipPayloadEvent.dataLength);





        TunerFilterEvent tunerEvent;

        TunerFilterEvent tunerEvent;

        tunerEvent.set<TunerFilterEvent::ipPayload>(std::move(tunerIpPayload));

        tunerEvent.set<TunerFilterEvent::ipPayload>(move(tunerIpPayload));

        res.push_back(std::move(tunerEvent));

        res.push_back(move(tunerEvent));

    }

    }

}

}





void TunerFilter::FilterCallback::getTemiEvent(

void TunerFilter::FilterCallback::getTemiEvent(

        std::vector<DemuxFilterEvent::Event>& events, std::vector<TunerFilterEvent>& res) {

        vector<DemuxFilterEvent::Event>& events, vector<TunerFilterEvent>& res) {

    for (DemuxFilterEvent::Event e : events) {

    for (DemuxFilterEvent::Event e : events) {

        DemuxFilterTemiEvent temiEvent = e.temi();

        DemuxFilterTemiEvent temiEvent = e.temi();

        TunerFilterTemiEvent tunerTemi;

        TunerFilterTemiEvent tunerTemi;





        tunerTemi.pts = static_cast<long>(temiEvent.pts);

        tunerTemi.pts = static_cast<long>(temiEvent.pts);

        tunerTemi.descrTag = static_cast<int8_t>(temiEvent.descrTag);

        tunerTemi.descrTag = static_cast<int8_t>(temiEvent.descrTag);

        std::vector<uint8_t> descrData = temiEvent.descrData;

        vector<uint8_t> descrData = temiEvent.descrData;

        tunerTemi.descrData.resize(descrData.size());

        tunerTemi.descrData.resize(descrData.size());

        copy(descrData.begin(), descrData.end(), tunerTemi.descrData.begin());

        copy(descrData.begin(), descrData.end(), tunerTemi.descrData.begin());





        TunerFilterEvent tunerEvent;

        TunerFilterEvent tunerEvent;

        tunerEvent.set<TunerFilterEvent::temi>(std::move(tunerTemi));

        tunerEvent.set<TunerFilterEvent::temi>(move(tunerTemi));

        res.push_back(std::move(tunerEvent));

        res.push_back(move(tunerEvent));

    }

    }

}

}





void TunerFilter::FilterCallback::getMonitorEvent(

void TunerFilter::FilterCallback::getMonitorEvent(

        std::vector<DemuxFilterEventExt::Event>& eventsExt, std::vector<TunerFilterEvent>& res) {

        vector<DemuxFilterEventExt::Event>& eventsExt, vector<TunerFilterEvent>& res) {

    DemuxFilterMonitorEvent monitorEvent = eventsExt[0].monitorEvent();

    DemuxFilterMonitorEvent monitorEvent = eventsExt[0].monitorEvent();

    TunerFilterMonitorEvent tunerMonitor;

    TunerFilterMonitorEvent tunerMonitor;
@@ -525,14 +784,14 @@ void TunerFilter::FilterCallback::getMonitorEvent( 
    }

    }





    TunerFilterEvent tunerEvent;

    TunerFilterEvent tunerEvent;

    tunerEvent.set<TunerFilterEvent::monitor>(std::move(tunerMonitor));

    tunerEvent.set<TunerFilterEvent::monitor>(move(tunerMonitor));

    res.push_back(std::move(tunerEvent));

    res.push_back(move(tunerEvent));

}

}





void TunerFilter::FilterCallback::getRestartEvent(

void TunerFilter::FilterCallback::getRestartEvent(

        std::vector<DemuxFilterEventExt::Event>& eventsExt, std::vector<TunerFilterEvent>& res) {

        vector<DemuxFilterEventExt::Event>& eventsExt, vector<TunerFilterEvent>& res) {

    TunerFilterEvent tunerEvent;

    TunerFilterEvent tunerEvent;

    tunerEvent.set<TunerFilterEvent::startId>(static_cast<int>(eventsExt[0].startId()));

    tunerEvent.set<TunerFilterEvent::startId>(static_cast<int>(eventsExt[0].startId()));

    res.push_back(std::move(tunerEvent));

    res.push_back(move(tunerEvent));

}

}

}  // namespace android
 
}  // namespace android

services/tuner/TunerFilter.h

+34 −0

File changed.

Preview size limit exceeded, changes collapsed.

services/tuner/aidl/android/media/tv/tuner/TunerDemuxIpAddress.aidl

0 → 100644
+28 −0
Original line number Original line Diff line number Diff line 
/**

 * 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.

 */



package android.media.tv.tuner;



/**

 * Demux ip address configure.

 *

 * {@hide}

 */

parcelable TunerDemuxIpAddress {

    boolean isIpV6;



    byte[] addr;

}

services/tuner/aidl/android/media/tv/tuner/TunerDemuxIpAddressSettings.aidl

0 → 100644
+34 −0
Original line number Original line Diff line number Diff line 
/**

 * 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.

 */



package android.media.tv.tuner;



import android.media.tv.tuner.TunerDemuxIpAddress;



/**

 * Filter Settings for an Ip filter.

 *

 * {@hide}

 */

parcelable TunerDemuxIpAddressSettings {

    TunerDemuxIpAddress srcIpAddress;



    TunerDemuxIpAddress dstIpAddress;



    char srcPort;



    char dstPort;

}

services/tuner/aidl/android/media/tv/tuner/TunerFilterAlpConfiguration.aidl

0 → 100644
+32 −0
Original line number Original line Diff line number Diff line 
/**

 * 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.

 */



package android.media.tv.tuner;



import android.media.tv.tuner.TunerFilterSettings;



/**

 * Filter Settings for an ALP filter.

 *

 * {@hide}

 */

parcelable TunerFilterAlpConfiguration {

    byte packetType;



    byte lengthType;



    TunerFilterSettings filterSettings;

}