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

#define LOG_TAG "TunerFilter"

#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::DemuxIpAddress;
using ::android::hardware::tv::tuner::V1_0::DemuxMmtpFilterType;
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::AudioStreamType;
using ::android::hardware::tv::tuner::V1_1::Constant;
using ::android::hardware::tv::tuner::V1_1::VideoStreamType;

namespace android {

using namespace std;

TunerFilter::TunerFilter(
        sp<IFilter> filter, int mainType, int subType) {
    mFilter = filter;
    mFilter_1_1 = ::android::hardware::tv::tuner::V1_1::IFilter::castFrom(filter);
    mMainType = mainType;
    mSubType = subType;
}

TunerFilter::~TunerFilter() {
    mFilter = nullptr;
    mFilter_1_1 = nullptr;
}

Status TunerFilter::getQueueDesc(AidlMQDesc* _aidl_return) {
    if (mFilter == NULL) {
        ALOGE("IFilter is not initialized");
        return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
    }

    MQDesc filterMQDesc;
    Result res;
    mFilter->getQueueDesc([&](Result r, const MQDesc& desc) {
        filterMQDesc = desc;
        res = r;
    });
    if (res != Result::SUCCESS) {
        return Status::fromServiceSpecificError(static_cast<int32_t>(res));
    }

    AidlMQDesc aidlMQDesc;
    unsafeHidlToAidlMQDescriptor<uint8_t, int8_t, SynchronizedReadWrite>(
                filterMQDesc,  &aidlMQDesc);
    *_aidl_return = move(aidlMQDesc);
    return Status::ok();
}

Status TunerFilter::getId(int32_t* _aidl_return) {
    if (mFilter == nullptr) {
        ALOGE("IFilter is not initialized");
        return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
    }

    Result res;
    mFilter->getId([&](Result r, uint32_t filterId) {
        res = r;
        mId = filterId;
    });
    if (res != Result::SUCCESS) {
        return Status::fromServiceSpecificError(static_cast<int32_t>(res));
    }
    *_aidl_return = mId;
    return Status::ok();
}

Status TunerFilter::getId64Bit(int64_t* _aidl_return) {
    if (mFilter_1_1 == nullptr) {
        ALOGE("IFilter_1_1 is not initialized");
        return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
    }

    Result res;
    mFilter_1_1->getId64Bit([&](Result r, uint64_t filterId) {
        res = r;
        mId64Bit = filterId;
    });
    if (res != Result::SUCCESS) {
        return ::ndk::ScopedAStatus::fromServiceSpecificError(static_cast<int32_t>(res));
    }
    *_aidl_return = mId64Bit;
    return Status::ok();
}

Status TunerFilter::configure(const TunerFilterConfiguration& config) {
    if (mFilter == nullptr) {
        ALOGE("IFilter is not initialized");
        return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
    }

    DemuxFilterSettings settings;
    switch (config.getTag()) {
        case TunerFilterConfiguration::ts: {
            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();
}

Status TunerFilter::configureMonitorEvent(int monitorEventType) {
    if (mFilter_1_1 == nullptr) {
        ALOGE("IFilter_1_1 is not initialized");
        return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
    }

    Result res = mFilter_1_1->configureMonitorEvent(monitorEventType);
    if (res != Result::SUCCESS) {
        return Status::fromServiceSpecificError(static_cast<int32_t>(res));
    }
    return Status::ok();
}

Status TunerFilter::configureIpFilterContextId(int cid) {
    if (mFilter_1_1 == nullptr) {
        ALOGE("IFilter_1_1 is not initialized");
        return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
    }

    Result res = mFilter_1_1->configureIpCid(cid);
    if (res != Result::SUCCESS) {
        return Status::fromServiceSpecificError(static_cast<int32_t>(res));
    }
    return Status::ok();
}

Status TunerFilter::configureAvStreamType(int avStreamType) {
    if (mFilter_1_1 == nullptr) {
        ALOGE("IFilter_1_1 is not initialized");
        return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
    }

    AvStreamType type;
    if (!getHidlAvStreamType(avStreamType, type)) {
        return Status::fromServiceSpecificError(static_cast<int32_t>(Result::INVALID_STATE));
    }

    Result res = mFilter_1_1->configureAvStreamType(type);
    if (res != Result::SUCCESS) {
        return Status::fromServiceSpecificError(static_cast<int32_t>(res));
    }
    return Status::ok();
}

Status TunerFilter::setDataSource(const shared_ptr<ITunerFilter>& filter) {
    if (mFilter == nullptr) {
        ALOGE("IFilter is not initialized");
        return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
    }

    ITunerFilter* tunerFilter = filter.get();
    sp<IFilter> hidlFilter = static_cast<TunerFilter*>(tunerFilter)->getHalFilter();
    Result res = mFilter->setDataSource(hidlFilter);
    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 = 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;
        }
        case TunerFilterSettings::pesData: {
            ts.filterSettings.pesData(getPesDataSettings(tunerSettings));
            break;
        }
        case TunerFilterSettings::record: {
            ts.filterSettings.record(getRecordSettings(tunerSettings));
            break;
        }
        default: {
            ts.filterSettings.noinit();
            break;
        }
    }
    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;
    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;
    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.begin(), sectionBits.filter.end());
            vector<uint8_t> mask(sectionBits.mask.begin(), sectionBits.mask.end());
            vector<uint8_t> mode(sectionBits.mode.begin(), sectionBits.mode.end());
            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) {
    if (mFilter_1_1 == nullptr) {
        ALOGE("IFilter_1_1 is not initialized");
        return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
    }

    Result res;
    mFilter_1_1->getAvSharedHandle([&](Result r, hidl_handle avMemory, uint64_t avMemSize) {
        res = r;
        if (res == Result::SUCCESS) {
            TunerFilterSharedHandleInfo info{
                .handle = dupToAidl(avMemory),
                .size = static_cast<int64_t>(avMemSize),
            };
            *_aidl_return = move(info);
        } else {
            _aidl_return = NULL;
        }
    });

    if (res != Result::SUCCESS) {
        return Status::fromServiceSpecificError(static_cast<int32_t>(res));
    }
    return Status::ok();
}

Status TunerFilter::releaseAvHandle(
        const ::aidl::android::hardware::common::NativeHandle& handle, int64_t avDataId) {
    if (mFilter == nullptr) {
        ALOGE("IFilter is not initialized");
        return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
    }

    Result res = mFilter->releaseAvHandle(hidl_handle(makeFromAidl(handle)), avDataId);
    if (res != Result::SUCCESS) {
        return Status::fromServiceSpecificError(static_cast<int32_t>(res));
    }
    return Status::ok();
}

Status TunerFilter::start() {
    if (mFilter == nullptr) {
        ALOGE("IFilter is not initialized");
        return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
    }
    Result res = mFilter->start();
    if (res != Result::SUCCESS) {
        return Status::fromServiceSpecificError(static_cast<int32_t>(res));
    }
    return Status::ok();
}

Status TunerFilter::stop() {
    if (mFilter == nullptr) {
        ALOGE("IFilter is not initialized");
        return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
    }
    Result res = mFilter->stop();
    if (res != Result::SUCCESS) {
        return Status::fromServiceSpecificError(static_cast<int32_t>(res));
    }
    return Status::ok();
}

Status TunerFilter::flush() {
    if (mFilter == nullptr) {
        ALOGE("IFilter is not initialized");
        return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
    }
    Result res = mFilter->flush();
    if (res != Result::SUCCESS) {
        return Status::fromServiceSpecificError(static_cast<int32_t>(res));
    }
    return Status::ok();
}

Status TunerFilter::close() {
    if (mFilter == nullptr) {
        ALOGE("IFilter is not initialized");
        return Status::fromServiceSpecificError(static_cast<int32_t>(Result::UNAVAILABLE));
    }
    Result res = mFilter->close();
    mFilter = NULL;
    mFilter_1_1 = NULL;

    if (res != Result::SUCCESS) {
        return Status::fromServiceSpecificError(static_cast<int32_t>(res));
    }
    return Status::ok();
}

sp<IFilter> TunerFilter::getHalFilter() {
    return mFilter;
}

bool TunerFilter::isAudioFilter() {
    return (mMainType == (int)DemuxFilterMainType::TS
                    && mSubType == (int)DemuxTsFilterType::AUDIO)
            || (mMainType == (int)DemuxFilterMainType::MMTP
                    && mSubType == (int)DemuxMmtpFilterType::AUDIO);
}

bool TunerFilter::isVideoFilter() {
    return (mMainType == (int)DemuxFilterMainType::TS
                    && mSubType == (int)DemuxTsFilterType::VIDEO)
            || (mMainType == (int)DemuxFilterMainType::MMTP
                    && mSubType == (int)DemuxMmtpFilterType::VIDEO);
}

bool TunerFilter::getHidlAvStreamType(int avStreamType, AvStreamType& type) {
    if (isAudioFilter()) {
        type.audio(static_cast<AudioStreamType>(avStreamType));
        return true;
    }

    if (isVideoFilter()) {
        type.video(static_cast<VideoStreamType>(avStreamType));
        return true;
    }

    return false;
}

/////////////// FilterCallback ///////////////////////

Return<void> TunerFilter::FilterCallback::onFilterStatus(DemuxFilterStatus status) {
    if (mTunerFilterCallback != NULL) {
        mTunerFilterCallback->onFilterStatus((int)status);
    }
    return Void();
}

Return<void> TunerFilter::FilterCallback::onFilterEvent(const DemuxFilterEvent& filterEvent) {
    vector<DemuxFilterEventExt::Event> emptyEventsExt;
    DemuxFilterEventExt emptyFilterEventExt {
            .events = emptyEventsExt,
    };
    onFilterEvent_1_1(filterEvent, emptyFilterEventExt);
    return Void();
}

Return<void> TunerFilter::FilterCallback::onFilterEvent_1_1(const DemuxFilterEvent& filterEvent,
        const DemuxFilterEventExt& filterEventExt) {
    if (mTunerFilterCallback != NULL) {
        vector<DemuxFilterEvent::Event> events = filterEvent.events;
        vector<DemuxFilterEventExt::Event> eventsExt = filterEventExt.events;
        vector<TunerFilterEvent> tunerEvent;

        getAidlFilterEvent(events, eventsExt, tunerEvent);
        mTunerFilterCallback->onFilterEvent(tunerEvent);
    }
    return Void();
}

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

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()) {
            case DemuxFilterEventExt::Event::hidl_discriminator::monitorEvent: {
                getMonitorEvent(eventsExt, tunerEvent);
                return;
            }
            case DemuxFilterEventExt::Event::hidl_discriminator::startId: {
                getRestartEvent(eventsExt, tunerEvent);
                return;
            }
            default: {
                break;
            }
        }
        return;
    }

    if (!events.empty()) {
        auto event = events[0];
        switch (event.getDiscriminator()) {
            case DemuxFilterEvent::Event::hidl_discriminator::media: {
                getMediaEvent(events, tunerEvent);
                break;
            }
            case DemuxFilterEvent::Event::hidl_discriminator::section: {
                getSectionEvent(events, tunerEvent);
                break;
            }
            case DemuxFilterEvent::Event::hidl_discriminator::pes: {
                getPesEvent(events, tunerEvent);
                break;
            }
            case DemuxFilterEvent::Event::hidl_discriminator::tsRecord: {
                getTsRecordEvent(events, eventsExt, tunerEvent);
                break;
            }
            case DemuxFilterEvent::Event::hidl_discriminator::mmtpRecord: {
                getMmtpRecordEvent(events, eventsExt, tunerEvent);
                break;
            }
            case DemuxFilterEvent::Event::hidl_discriminator::download: {
                getDownloadEvent(events, tunerEvent);
                break;
            }
            case DemuxFilterEvent::Event::hidl_discriminator::ipPayload: {
                getIpPayloadEvent(events, tunerEvent);
                break;
            }
            case DemuxFilterEvent::Event::hidl_discriminator::temi: {
                getTemiEvent(events, tunerEvent);
                break;
            }
            default: {
                break;
            }
        }
    }
}

void TunerFilter::FilterCallback::getMediaEvent(
        vector<DemuxFilterEvent::Event>& events, vector<TunerFilterEvent>& res) {
    for (DemuxFilterEvent::Event e : events) {
        DemuxFilterMediaEvent mediaEvent = e.media();
        TunerFilterMediaEvent tunerMedia;

        tunerMedia.streamId = static_cast<char16_t>(mediaEvent.streamId);
        tunerMedia.isPtsPresent = mediaEvent.isPtsPresent;
        tunerMedia.pts = static_cast<long>(mediaEvent.pts);
        tunerMedia.dataLength = static_cast<int>(mediaEvent.dataLength);
        tunerMedia.offset = static_cast<int>(mediaEvent.offset);
        tunerMedia.isSecureMemory = mediaEvent.isSecureMemory;
        tunerMedia.avDataId = static_cast<long>(mediaEvent.avDataId);
        tunerMedia.mpuSequenceNumber = static_cast<int>(mediaEvent.mpuSequenceNumber);
        tunerMedia.isPesPrivateData = mediaEvent.isPesPrivateData;

        if (mediaEvent.extraMetaData.getDiscriminator() ==
                DemuxFilterMediaEvent::ExtraMetaData::hidl_discriminator::audio) {
            tunerMedia.isAudioExtraMetaData = true;
            tunerMedia.audio = {
                .adFade = static_cast<int8_t>(
                        mediaEvent.extraMetaData.audio().adFade),
                .adPan = static_cast<int8_t>(
                        mediaEvent.extraMetaData.audio().adPan),
                .versionTextTag = static_cast<int8_t>(
                        mediaEvent.extraMetaData.audio().versionTextTag),
                .adGainCenter = static_cast<int8_t>(
                        mediaEvent.extraMetaData.audio().adGainCenter),
                .adGainFront = static_cast<int8_t>(
                        mediaEvent.extraMetaData.audio().adGainFront),
                .adGainSurround = static_cast<int8_t>(
                        mediaEvent.extraMetaData.audio().adGainSurround),
            };
        } else {
            tunerMedia.isAudioExtraMetaData = false;
        }

        if (mediaEvent.avMemory.getNativeHandle() != nullptr) {
            tunerMedia.avMemory = dupToAidl(mediaEvent.avMemory.getNativeHandle());
        }

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

void TunerFilter::FilterCallback::getSectionEvent(
        vector<DemuxFilterEvent::Event>& events, vector<TunerFilterEvent>& res) {
    for (DemuxFilterEvent::Event e : events) {
        DemuxFilterSectionEvent sectionEvent = e.section();
        TunerFilterSectionEvent tunerSection;

        tunerSection.tableId = static_cast<char16_t>(sectionEvent.tableId);
        tunerSection.version = static_cast<char16_t>(sectionEvent.version);
        tunerSection.sectionNum = static_cast<char16_t>(sectionEvent.sectionNum);
        tunerSection.dataLength = static_cast<char16_t>(sectionEvent.dataLength);

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

void TunerFilter::FilterCallback::getPesEvent(
        vector<DemuxFilterEvent::Event>& events, vector<TunerFilterEvent>& res) {
    for (DemuxFilterEvent::Event e : events) {
        DemuxFilterPesEvent pesEvent = e.pes();
        TunerFilterPesEvent tunerPes;

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

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

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

        TunerFilterScIndexMask scIndexMask;
        if (tsRecordEvent.scIndexMask.getDiscriminator()
                == DemuxFilterTsRecordEvent::ScIndexMask::hidl_discriminator::sc) {
            scIndexMask.set<TunerFilterScIndexMask::sc>(
                    static_cast<int>(tsRecordEvent.scIndexMask.sc()));
        } else if (tsRecordEvent.scIndexMask.getDiscriminator()
                == DemuxFilterTsRecordEvent::ScIndexMask::hidl_discriminator::scHevc) {
            scIndexMask.set<TunerFilterScIndexMask::scHevc>(
                    static_cast<int>(tsRecordEvent.scIndexMask.scHevc()));
        }

        if (tsRecordEvent.pid.getDiscriminator() == DemuxPid::hidl_discriminator::tPid) {
            tunerTsRecord.pid = static_cast<char16_t>(tsRecordEvent.pid.tPid());
        } else {
            tunerTsRecord.pid = static_cast<char16_t>(Constant::INVALID_TS_PID);
        }

        tunerTsRecord.scIndexMask = scIndexMask;
        tunerTsRecord.tsIndexMask = static_cast<int>(tsRecordEvent.tsIndexMask);
        tunerTsRecord.byteNumber = static_cast<long>(tsRecordEvent.byteNumber);

        if (eventsExt.size() > i && eventsExt[i].getDiscriminator() ==
                    DemuxFilterEventExt::Event::hidl_discriminator::tsRecord) {
            tunerTsRecord.isExtended = true;
            tunerTsRecord.pts = static_cast<long>(eventsExt[i].tsRecord().pts);
            tunerTsRecord.firstMbInSlice = static_cast<int>(eventsExt[i].tsRecord().firstMbInSlice);
        } else {
            tunerTsRecord.isExtended = false;
        }

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

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

        tunerMmtpRecord.scHevcIndexMask = static_cast<int>(mmtpRecordEvent.scHevcIndexMask);
        tunerMmtpRecord.byteNumber = static_cast<long>(mmtpRecordEvent.byteNumber);

        if (eventsExt.size() > i && eventsExt[i].getDiscriminator() ==
                    DemuxFilterEventExt::Event::hidl_discriminator::mmtpRecord) {
            tunerMmtpRecord.isExtended = true;
            tunerMmtpRecord.pts = static_cast<long>(eventsExt[i].mmtpRecord().pts);
            tunerMmtpRecord.mpuSequenceNumber =
                    static_cast<int>(eventsExt[i].mmtpRecord().mpuSequenceNumber);
            tunerMmtpRecord.firstMbInSlice =
                    static_cast<int>(eventsExt[i].mmtpRecord().firstMbInSlice);
            tunerMmtpRecord.tsIndexMask = static_cast<int>(eventsExt[i].mmtpRecord().tsIndexMask);
        } else {
            tunerMmtpRecord.isExtended = false;
        }

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

void TunerFilter::FilterCallback::getDownloadEvent(
        vector<DemuxFilterEvent::Event>& events, vector<TunerFilterEvent>& res) {
    for (DemuxFilterEvent::Event e : events) {
        DemuxFilterDownloadEvent downloadEvent = e.download();
        TunerFilterDownloadEvent tunerDownload;

        tunerDownload.itemId = static_cast<int>(downloadEvent.itemId);
        tunerDownload.itemFragmentIndex = static_cast<int>(downloadEvent.itemFragmentIndex);
        tunerDownload.mpuSequenceNumber = static_cast<int>(downloadEvent.mpuSequenceNumber);
        tunerDownload.lastItemFragmentIndex = static_cast<int>(downloadEvent.lastItemFragmentIndex);
        tunerDownload.dataLength = static_cast<char16_t>(downloadEvent.dataLength);

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

void TunerFilter::FilterCallback::getIpPayloadEvent(
        vector<DemuxFilterEvent::Event>& events, vector<TunerFilterEvent>& res) {
    for (DemuxFilterEvent::Event e : events) {
        DemuxFilterIpPayloadEvent ipPayloadEvent = e.ipPayload();
        TunerFilterIpPayloadEvent tunerIpPayload;

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

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

void TunerFilter::FilterCallback::getTemiEvent(
        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);
        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>(move(tunerTemi));
        res.push_back(move(tunerEvent));
    }
}

void TunerFilter::FilterCallback::getMonitorEvent(
        vector<DemuxFilterEventExt::Event>& eventsExt, vector<TunerFilterEvent>& res) {
    DemuxFilterMonitorEvent monitorEvent = eventsExt[0].monitorEvent();
    TunerFilterMonitorEvent tunerMonitor;

    switch (monitorEvent.getDiscriminator()) {
        case DemuxFilterMonitorEvent::hidl_discriminator::scramblingStatus: {
            tunerMonitor.set<TunerFilterMonitorEvent::scramblingStatus>(
                    static_cast<int>(monitorEvent.scramblingStatus()));
            break;
        }
        case DemuxFilterMonitorEvent::hidl_discriminator::cid: {
            tunerMonitor.set<TunerFilterMonitorEvent::cid>(static_cast<int>(monitorEvent.cid()));
            break;
        }
    }

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

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