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

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

Add test scan message during Frontend.scan in the Frontend default impl 

Note that this CL also fixes the broken Tuner 1.0 VTS due to the
filter testing events, which trigger the Tuner 1.0 VTS to read data
from the events meta data

Test: atest android.media.tv.tuner.cts
Test: atest VtsHalTvTunerV1_0TargetTest
Test: atest VtsHalTvTunerV1_1TargetTest

Bug: 181152149
Bug: 181242574
Change-Id: Ic6416e085dc2b81c3410db9e08fcea03cb8813d2
parent 013fc384

tv/tuner/1.0/vts/functional/FilterTests.cpp

+11 −20
Original line number Diff line number Diff line
@@ -78,24 +78,20 @@ bool FilterCallback::readFilterEventData() { 
    DemuxFilterEvent filterEvent = mFilterEvent;

    ALOGW("[vts] reading from filter FMQ or buffer %d", mFilterId);

    // todo separate filter handlers

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

        switch (mFilterEventType) {

            case FilterEventType::SECTION:

                mDataLength = filterEvent.events[i].section().dataLength;

    for (auto event : filterEvent.events) {

        switch (event.getDiscriminator()) {

            case DemuxFilterEvent::Event::hidl_discriminator::section:

                mDataLength = event.section().dataLength;

                break;

            case FilterEventType::PES:

                mDataLength = filterEvent.events[i].pes().dataLength;

                break;

            case FilterEventType::MEDIA:

                return dumpAvData(filterEvent.events[i].media());

            case FilterEventType::RECORD:

                return readRecordData(filterEvent.events[i].tsRecord());

            case FilterEventType::MMTPRECORD:

                break;

            case FilterEventType::DOWNLOAD:

            case DemuxFilterEvent::Event::hidl_discriminator::pes:

                mDataLength = event.pes().dataLength;

                break;

            case DemuxFilterEvent::Event::hidl_discriminator::media:

                return dumpAvData(event.media());

            case DemuxFilterEvent::Event::hidl_discriminator::tsRecord:

                return readRecordData(event.tsRecord());

            default:

                break;

                continue;

        }

        // EXPECT_TRUE(mDataLength == goldenDataOutputBuffer.size()) << "buffer size does not

        // match";
@@ -150,11 +146,6 @@ AssertionResult FilterTests::openFilterInDemux(DemuxFilterType type, uint32_t bu 
                           mFilter = filter;

                           status = result;

                       });



    if (status == Result::SUCCESS) {

        mFilterCallback->setFilterEventType(getFilterEventType(type));

    }



    return AssertionResult(status == Result::SUCCESS);

}

tv/tuner/1.0/vts/functional/FilterTests.h

+0 −60
Original line number Diff line number Diff line
@@ -66,17 +66,6 @@ using ::testing::AssertionResult; 


using namespace std;



enum FilterEventType : uint8_t {

    UNDEFINED,

    SECTION,

    MEDIA,

    PES,

    RECORD,

    MMTPRECORD,

    DOWNLOAD,

    TEMI,

};



using FilterMQ = MessageQueue<uint8_t, kSynchronizedReadWrite>;

using MQDesc = MQDescriptorSync<uint8_t>;
@@ -104,7 +93,6 @@ class FilterCallback : public IFilterCallback { 


    void setFilterId(uint32_t filterId) { mFilterId = filterId; }

    void setFilterInterface(sp<IFilter> filter) { mFilter = filter; }

    void setFilterEventType(FilterEventType type) { mFilterEventType = type; }



    void testFilterDataOutput();
@@ -130,7 +118,6 @@ class FilterCallback : public IFilterCallback { 


    uint32_t mFilterId;

    sp<IFilter> mFilter;

    FilterEventType mFilterEventType;

    std::unique_ptr<FilterMQ> mFilterMQ;

    EventFlag* mFilterMQEventFlag;

    DemuxFilterEvent mFilterEvent;
@@ -168,53 +155,6 @@ class FilterTests { 
    AssertionResult closeFilter(uint32_t filterId);

    AssertionResult closeTimeFilter();



    FilterEventType getFilterEventType(DemuxFilterType type) {

        FilterEventType eventType = FilterEventType::UNDEFINED;

        switch (type.mainType) {

            case DemuxFilterMainType::TS:

                switch (type.subType.tsFilterType()) {

                    case DemuxTsFilterType::UNDEFINED:

                        break;

                    case DemuxTsFilterType::SECTION:

                        eventType = FilterEventType::SECTION;

                        break;

                    case DemuxTsFilterType::PES:

                        eventType = FilterEventType::PES;

                        break;

                    case DemuxTsFilterType::TS:

                        break;

                    case DemuxTsFilterType::AUDIO:

                    case DemuxTsFilterType::VIDEO:

                        eventType = FilterEventType::MEDIA;

                        break;

                    case DemuxTsFilterType::PCR:

                        break;

                    case DemuxTsFilterType::RECORD:

                        eventType = FilterEventType::RECORD;

                        break;

                    case DemuxTsFilterType::TEMI:

                        eventType = FilterEventType::TEMI;

                        break;

                }

                break;

            case DemuxFilterMainType::MMTP:

                /*mmtpSettings*/

                break;

            case DemuxFilterMainType::IP:

                /*ipSettings*/

                break;

            case DemuxFilterMainType::TLV:

                /*tlvSettings*/

                break;

            case DemuxFilterMainType::ALP:

                /*alpSettings*/

                break;

            default:

                break;

        }

        return eventType;

    }



  protected:

    static AssertionResult failure() { return ::testing::AssertionFailure(); }

tv/tuner/1.1/default/Filter.cpp

+23 −7
Original line number Diff line number Diff line
@@ -145,26 +145,36 @@ Return<Result> Filter::start() { 
        case DemuxFilterMainType::TS:

            mCallback->onFilterEvent(createMediaEvent());

            mCallback->onFilterEvent(createTsRecordEvent());

            mCallback_1_1->onFilterEvent_1_1(createTsRecordEvent(), createTsRecordEventExt());

            mCallback->onFilterEvent(createTemiEvent());

            // clients could still pass 1.0 callback

            if (mCallback_1_1 != NULL) {

                mCallback_1_1->onFilterEvent_1_1(createTsRecordEvent(), createTsRecordEventExt());

            }

            break;

        case DemuxFilterMainType::MMTP:

            mCallback->onFilterEvent(createDownloadEvent());

            mCallback->onFilterEvent(createMmtpRecordEvent());

            mCallback_1_1->onFilterEvent_1_1(createMmtpRecordEvent(), createMmtpRecordEventExt());

            if (mCallback_1_1 != NULL) {

                mCallback_1_1->onFilterEvent_1_1(createMmtpRecordEvent(),

                                                 createMmtpRecordEventExt());

            }

            break;

        case DemuxFilterMainType::IP:

            mCallback->onFilterEvent(createSectionEvent());

            mCallback->onFilterEvent(createIpPayloadEvent());

            break;

        case DemuxFilterMainType::TLV: {

            if (mCallback_1_1 != NULL) {

                DemuxFilterEvent emptyFilterEvent;

                mCallback_1_1->onFilterEvent_1_1(emptyFilterEvent, createMonitorEvent());

            }

            break;

        }

        case DemuxFilterMainType::ALP: {

            if (mCallback_1_1 != NULL) {

                DemuxFilterEvent emptyFilterEvent;

                mCallback_1_1->onFilterEvent_1_1(emptyFilterEvent, createRestartEvent());

            }

            break;

        }

        default:
@@ -967,7 +977,6 @@ DemuxFilterEvent Filter::createMediaEvent() { 
            .dataLength = 3,

            .offset = 4,

            .isSecureMemory = true,

            .avDataId = 5,

            .mpuSequenceNumber = 6,

            .isPesPrivateData = true,

    });
@@ -988,9 +997,16 @@ DemuxFilterEvent Filter::createMediaEvent() { 


    native_handle_t* nativeHandle = createNativeHandle(av_fd);

    if (nativeHandle == NULL) {

        ::close(av_fd);

        ALOGE("[Filter] Failed to create native_handle %d", errno);

        return event;

    }



    // Create a dataId and add a <dataId, av_fd> pair into the dataId2Avfd map

    uint64_t dataId = mLastUsedDataId++ /*createdUID*/;

    mDataId2Avfd[dataId] = dup(av_fd);

    event.events[0].media().avDataId = dataId;



    hidl_handle handle;

    handle.setTo(nativeHandle, /*shouldOwn=*/true);

    event.events[0].media().avMemory = std::move(handle);

tv/tuner/1.1/default/Frontend.cpp

+92 −18
Original line number Diff line number Diff line
@@ -88,18 +88,6 @@ Return<Result> Frontend::stopTune() { 


Return<Result> Frontend::scan(const FrontendSettings& settings, FrontendScanType type) {

    ALOGV("%s", __FUNCTION__);



    if (mType == FrontendType::ATSC) {

        FrontendScanMessage msg;

        msg.isLocked(true);

        mCallback->onScanMessage(FrontendScanMessageType::LOCKED, msg);

        mIsLocked = true;

        return Result::SUCCESS;

    }

    if (mType != FrontendType::DVBT) {

        return Result::UNAVAILABLE;

    }



    FrontendScanMessage msg;



    if (mIsLocked) {
@@ -108,15 +96,96 @@ Return<Result> Frontend::scan(const FrontendSettings& settings, FrontendScanType 
        return Result::SUCCESS;

    }



    uint32_t frequency = settings.dvbt().frequency;

    uint32_t frequency;

    switch (settings.getDiscriminator()) {

        case FrontendSettings::hidl_discriminator::analog:

            frequency = settings.analog().frequency;

            break;

        case FrontendSettings::hidl_discriminator::atsc:

            frequency = settings.atsc().frequency;

            break;

        case FrontendSettings::hidl_discriminator::atsc3:

            frequency = settings.atsc3().frequency;

            break;

        case FrontendSettings::hidl_discriminator::dvbs:

            frequency = settings.dvbs().frequency;

            break;

        case FrontendSettings::hidl_discriminator::dvbc:

            frequency = settings.dvbc().frequency;

            break;

        case FrontendSettings::hidl_discriminator::dvbt:

            frequency = settings.dvbt().frequency;

            break;

        case FrontendSettings::hidl_discriminator::isdbs:

            frequency = settings.isdbs().frequency;

            break;

        case FrontendSettings::hidl_discriminator::isdbs3:

            frequency = settings.isdbs3().frequency;

            break;

        case FrontendSettings::hidl_discriminator::isdbt:

            frequency = settings.isdbt().frequency;

            break;

    }



    if (type == FrontendScanType::SCAN_BLIND) {

        frequency += 100;

    }



    msg.frequencies({frequency});

    mCallback->onScanMessage(FrontendScanMessageType::FREQUENCY, msg);

    msg.isLocked(true);

    mCallback->onScanMessage(FrontendScanMessageType::LOCKED, msg);

    mIsLocked = true;



    msg.progressPercent(20);

    mCallback->onScanMessage(FrontendScanMessageType::PROGRESS_PERCENT, msg);



    msg.symbolRates({30});

    mCallback->onScanMessage(FrontendScanMessageType::SYMBOL_RATE, msg);



    if (mType == FrontendType::DVBT) {

        msg.hierarchy(FrontendDvbtHierarchy::HIERARCHY_NON_NATIVE);

        mCallback->onScanMessage(FrontendScanMessageType::HIERARCHY, msg);

    }



    if (mType == FrontendType::ANALOG) {

        msg.analogType(FrontendAnalogType::PAL);

        mCallback->onScanMessage(FrontendScanMessageType::ANALOG_TYPE, msg);

    }



    msg.plpIds({3});

    mCallback->onScanMessage(FrontendScanMessageType::PLP_IDS, msg);



    msg.groupIds({2});

    mCallback->onScanMessage(FrontendScanMessageType::GROUP_IDS, msg);



    msg.inputStreamIds({1});

    mCallback->onScanMessage(FrontendScanMessageType::INPUT_STREAM_IDS, msg);



    FrontendScanMessage::Standard s;

    switch (mType) {

        case FrontendType::DVBT:

            s.tStd(FrontendDvbtStandard::AUTO);

            msg.std(s);

            mCallback->onScanMessage(FrontendScanMessageType::STANDARD, msg);

            break;

        case FrontendType::DVBS:

            s.sStd(FrontendDvbsStandard::AUTO);

            msg.std(s);

            mCallback->onScanMessage(FrontendScanMessageType::STANDARD, msg);

            break;

        case FrontendType::ANALOG:

            s.sifStd(FrontendAnalogSifStandard::AUTO);

            msg.std(s);

            mCallback->onScanMessage(FrontendScanMessageType::STANDARD, msg);

            break;

        default:

            break;

    }



    FrontendScanAtsc3PlpInfo info{

            .plpId = 1,

            .bLlsFlag = false,

    };

    msg.atsc3PlpInfos({info});

    mCallback->onScanMessage(FrontendScanMessageType::ATSC3_PLP_INFO, msg);



    sp<V1_1::IFrontendCallback> frontendCallback_v1_1 =

            V1_1::IFrontendCallback::castFrom(mCallback);
@@ -129,15 +198,20 @@ Return<Result> Frontend::scan(const FrontendSettings& settings, FrontendScanType 
        frontendCallback_v1_1->onScanMessageExt1_1(

                V1_1::FrontendScanMessageTypeExt1_1::HIGH_PRIORITY, msg);

    } else {

        ALOGD("[Filter] Couldn't cast to V1_1 IFrontendCallback");

        ALOGD("[Frontend] Couldn't cast to V1_1 IFrontendCallback");

    }



    msg.isLocked(true);

    mCallback->onScanMessage(FrontendScanMessageType::LOCKED, msg);

    mIsLocked = true;



    return Result::SUCCESS;

}



Return<Result> Frontend::scan_1_1(const FrontendSettings& settings, FrontendScanType type,

                                  const V1_1::FrontendSettingsExt1_1& /*settingsExt1_1*/) {

                                  const V1_1::FrontendSettingsExt1_1& settingsExt1_1) {

    ALOGV("%s", __FUNCTION__);

    ALOGD("[Frontend] scan_1_1 end frequency %d", settingsExt1_1.endFrequency);

    return scan(settings, type);

}