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

Commit db01aee8 authored by Amy Zhang's avatar Amy Zhang
Browse files

Complete TunerFilterSettings aidl interfaces and TunerFilter

implementations

Test: make
Bug: 159067322
Change-Id: I1246b0199ef8963ca6dd465c99de85e37d4a08f7
parent 7c2c2efb
Loading
Loading
Loading
Loading
+325 −66
Original line number Diff line number Diff line
@@ -18,17 +18,24 @@

#include "TunerFilter.h"

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

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::DemuxFilterSettings;
using ::android::hardware::tv::tuner::V1_0::DemuxIpAddress;
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::Result;
using ::android::hardware::tv::tuner::V1_1::Constant;

namespace android {

using namespace std;

TunerFilter::TunerFilter(
        sp<IFilter> filter, sp<IFilterCallback> callback) {
    mFilter = filter;
@@ -42,13 +49,6 @@ TunerFilter::~TunerFilter() {
    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) {
    if (mFilter == nullptr) {
        ALOGE("IFilter is not initialized");
@@ -91,32 +91,291 @@ Status TunerFilter::configure(const TunerFilterConfiguration& config) {
        return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
    }

    // TODO: more filter types.
    TunerFilterSettings tunerSettings;
    DemuxFilterSettings halSettings;
    DemuxFilterSettings settings;
    switch (config.getTag()) {
        case TunerFilterConfiguration::ts: {
            uint16_t tpid = static_cast<uint16_t>(config.get<TunerFilterConfiguration::ts>().tpid);
            tunerSettings = config.get<TunerFilterConfiguration::ts>().filterSettings;
            getHidlTsSettings(config, settings);
            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{
                .tpid = tpid,
        .tpid = static_cast<uint16_t>(tsConf.tpid),
    };

    TunerFilterSettings tunerSettings = tsConf.filterSettings;
    switch (tunerSettings.getTag()) {
        case TunerFilterSettings::av: {
            ts.filterSettings.av(getAvSettings(tunerSettings));
            break;
        }
        case TunerFilterSettings::section: {
            ts.filterSettings.section(getSectionSettings(tunerSettings));
            break;
        }
            halSettings.ts(ts);
        case TunerFilterSettings::pesData: {
            ts.filterSettings.pesData(getPesDataSettings(tunerSettings));
            break;
        }
        case TunerFilterSettings::record: {
            ts.filterSettings.record(getRecordSettings(tunerSettings));
            break;
        }
    Result res = mFilter->configure(halSettings);
    if (res != Result::SUCCESS) {
        return Status::fromServiceSpecificError(static_cast<int32_t>(res));
        default: {
            ts.filterSettings.noinit();
            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) {
@@ -133,7 +392,7 @@ Status TunerFilter::getAvSharedHandleInfo(TunerFilterSharedHandleInfo* _aidl_ret
                .handle = dupToAidl(hidl_handle(avMemory.getNativeHandle())),
                .size = static_cast<int64_t>(avMemSize),
            };
            *_aidl_return = std::move(info);
            *_aidl_return = move(info);
        } else {
            _aidl_return = NULL;
        }
@@ -219,7 +478,7 @@ Return<void> TunerFilter::FilterCallback::onFilterStatus(DemuxFilterStatus statu
}

Return<void> TunerFilter::FilterCallback::onFilterEvent(const DemuxFilterEvent& filterEvent) {
    std::vector<DemuxFilterEventExt::Event> emptyEventsExt;
    vector<DemuxFilterEventExt::Event> emptyEventsExt;
    DemuxFilterEventExt emptyFilterEventExt {
            .events = emptyEventsExt,
    };
@@ -230,9 +489,9 @@ Return<void> TunerFilter::FilterCallback::onFilterEvent(const DemuxFilterEvent&
Return<void> TunerFilter::FilterCallback::onFilterEvent_1_1(const DemuxFilterEvent& filterEvent,
        const DemuxFilterEventExt& filterEventExt) {
    if (mTunerFilterCallback != NULL) {
        std::vector<DemuxFilterEvent::Event> events = filterEvent.events;
        std::vector<DemuxFilterEventExt::Event> eventsExt = filterEventExt.events;
        std::vector<TunerFilterEvent> tunerEvent;
        vector<DemuxFilterEvent::Event> events = filterEvent.events;
        vector<DemuxFilterEventExt::Event> eventsExt = filterEventExt.events;
        vector<TunerFilterEvent> tunerEvent;

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

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

void TunerFilter::FilterCallback::getAidlFilterEvent(std::vector<DemuxFilterEvent::Event>& events,
        std::vector<DemuxFilterEventExt::Event>& eventsExt,
        std::vector<TunerFilterEvent>& tunerEvent) {
void TunerFilter::FilterCallback::getAidlFilterEvent(vector<DemuxFilterEvent::Event>& events,
        vector<DemuxFilterEventExt::Event>& eventsExt,
        vector<TunerFilterEvent>& tunerEvent) {
    if (events.empty() && !eventsExt.empty()) {
        auto eventExt = eventsExt[0];
        switch (eventExt.getDiscriminator()) {
@@ -305,7 +564,7 @@ void TunerFilter::FilterCallback::getAidlFilterEvent(std::vector<DemuxFilterEven
}

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) {
        DemuxFilterMediaEvent mediaEvent = e.media();
        TunerFilterMediaEvent tunerMedia;
@@ -346,13 +605,13 @@ void TunerFilter::FilterCallback::getMediaEvent(
        }

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

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) {
        DemuxFilterSectionEvent sectionEvent = e.section();
        TunerFilterSectionEvent tunerSection;
@@ -363,13 +622,13 @@ void TunerFilter::FilterCallback::getSectionEvent(
        tunerSection.dataLength = static_cast<char>(sectionEvent.dataLength);

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

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) {
        DemuxFilterPesEvent pesEvent = e.pes();
        TunerFilterPesEvent tunerPes;
@@ -379,13 +638,13 @@ void TunerFilter::FilterCallback::getPesEvent(
        tunerPes.mpuSequenceNumber = static_cast<int>(pesEvent.mpuSequenceNumber);

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

void TunerFilter::FilterCallback::getTsRecordEvent(std::vector<DemuxFilterEvent::Event>& events,
        std::vector<DemuxFilterEventExt::Event>& eventsExt, std::vector<TunerFilterEvent>& res) {
void TunerFilter::FilterCallback::getTsRecordEvent(vector<DemuxFilterEvent::Event>& events,
        vector<DemuxFilterEventExt::Event>& eventsExt, vector<TunerFilterEvent>& res) {
    for (int i = 0; i < events.size(); i++) {
        TunerFilterTsRecordEvent tunerTsRecord;
        DemuxFilterTsRecordEvent tsRecordEvent = events[i].tsRecord();
@@ -421,13 +680,13 @@ void TunerFilter::FilterCallback::getTsRecordEvent(std::vector<DemuxFilterEvent:
        }

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

void TunerFilter::FilterCallback::getMmtpRecordEvent(std::vector<DemuxFilterEvent::Event>& events,
        std::vector<DemuxFilterEventExt::Event>& eventsExt, std::vector<TunerFilterEvent>& res) {
void TunerFilter::FilterCallback::getMmtpRecordEvent(vector<DemuxFilterEvent::Event>& events,
        vector<DemuxFilterEventExt::Event>& eventsExt, vector<TunerFilterEvent>& res) {
    for (int i = 0; i < events.size(); i++) {
        TunerFilterMmtpRecordEvent tunerMmtpRecord;
        DemuxFilterMmtpRecordEvent mmtpRecordEvent = events[i].mmtpRecord();
@@ -449,13 +708,13 @@ void TunerFilter::FilterCallback::getMmtpRecordEvent(std::vector<DemuxFilterEven
        }

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

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) {
        DemuxFilterDownloadEvent downloadEvent = e.download();
        TunerFilterDownloadEvent tunerDownload;
@@ -467,13 +726,13 @@ void TunerFilter::FilterCallback::getDownloadEvent(
        tunerDownload.dataLength = static_cast<char>(downloadEvent.dataLength);

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

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) {
        DemuxFilterIpPayloadEvent ipPayloadEvent = e.ipPayload();
        TunerFilterIpPayloadEvent tunerIpPayload;
@@ -481,31 +740,31 @@ void TunerFilter::FilterCallback::getIpPayloadEvent(
        tunerIpPayload.dataLength = static_cast<char>(ipPayloadEvent.dataLength);

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

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) {
        DemuxFilterTemiEvent temiEvent = e.temi();
        TunerFilterTemiEvent tunerTemi;

        tunerTemi.pts = static_cast<long>(temiEvent.pts);
        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());
        copy(descrData.begin(), descrData.end(), tunerTemi.descrData.begin());

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

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();
    TunerFilterMonitorEvent tunerMonitor;

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

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

void TunerFilter::FilterCallback::getRestartEvent(
        std::vector<DemuxFilterEventExt::Event>& eventsExt, std::vector<TunerFilterEvent>& res) {
        vector<DemuxFilterEventExt::Event>& eventsExt, vector<TunerFilterEvent>& res) {
    TunerFilterEvent tunerEvent;
    tunerEvent.set<TunerFilterEvent::startId>(static_cast<int>(eventsExt[0].startId()));
    res.push_back(std::move(tunerEvent));
    res.push_back(move(tunerEvent));
}
}  // namespace android
+34 −0

File changed.

Preview size limit exceeded, changes collapsed.

+28 −0
Original line number 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;
}
+34 −0
Original line number 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;
}
+32 −0
Original line number 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;
}
Loading