tv/tuner/1.1/vts/functional/FrontendTests.cpp

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

#include "FrontendTests.h"

Return<void> FrontendCallback::onEvent(FrontendEventType frontendEventType) {
    android::Mutex::Autolock autoLock(mMsgLock);
    ALOGD("[vts] frontend event received. Type: %d", frontendEventType);
    mEventReceived = true;
    mMsgCondition.signal();
    switch (frontendEventType) {
        case FrontendEventType::LOCKED:
            mLockMsgReceived = true;
            mLockMsgCondition.signal();
            return Void();
        default:
            // do nothing
            return Void();
    }
}

Return<void> FrontendCallback::onScanMessage(FrontendScanMessageType type,
                                             const FrontendScanMessage& message) {
    android::Mutex::Autolock autoLock(mMsgLock);
    while (!mScanMsgProcessed) {
        mMsgCondition.wait(mMsgLock);
    }
    ALOGD("[vts] frontend scan message. Type: %d", type);
    mScanMessageReceived = true;
    mScanMsgProcessed = false;
    mScanMessageType = type;
    mScanMessage = message;
    mMsgCondition.signal();
    return Void();
}

Return<void> FrontendCallback::onScanMessageExt1_1(FrontendScanMessageTypeExt1_1 type,
                                                   const FrontendScanMessageExt1_1& message) {
    android::Mutex::Autolock autoLock(mMsgLock);
    ALOGD("[vts] frontend ext1_1 scan message. Type: %d", type);
    switch (message.getDiscriminator()) {
        case FrontendScanMessageExt1_1::hidl_discriminator::modulation:
            readFrontendScanMessageExt1_1Modulation(message.modulation());
            break;
        case FrontendScanMessageExt1_1::hidl_discriminator::isHighPriority:
            ALOGD("[vts] frontend ext1_1 scan message high priority: %d", message.isHighPriority());
            break;
        case FrontendScanMessageExt1_1::hidl_discriminator::annex:
            ALOGD("[vts] frontend ext1_1 scan message dvbc annex: %hhu", message.annex());
            break;
        default:
            break;
    }
    return Void();
}

void FrontendCallback::readFrontendScanMessageExt1_1Modulation(FrontendModulation modulation) {
    switch (modulation.getDiscriminator()) {
        case FrontendModulation::hidl_discriminator::dvbc:
            ALOGD("[vts] frontend ext1_1 scan message modulation dvbc: %d", modulation.dvbc());
            break;
        case FrontendModulation::hidl_discriminator::dvbs:
            ALOGD("[vts] frontend ext1_1 scan message modulation dvbs: %d", modulation.dvbs());
            break;
        case FrontendModulation::hidl_discriminator::isdbs:
            ALOGD("[vts] frontend ext1_1 scan message modulation isdbs: %d", modulation.isdbs());
            break;
        case FrontendModulation::hidl_discriminator::isdbs3:
            ALOGD("[vts] frontend ext1_1 scan message modulation isdbs3: %d", modulation.isdbs3());
            break;
        case FrontendModulation::hidl_discriminator::isdbt:
            ALOGD("[vts] frontend ext1_1 scan message modulation isdbt: %d", modulation.isdbt());
            break;
        case FrontendModulation::hidl_discriminator::atsc:
            ALOGD("[vts] frontend ext1_1 scan message modulation atsc: %d", modulation.atsc());
            break;
        case FrontendModulation::hidl_discriminator::atsc3:
            ALOGD("[vts] frontend ext1_1 scan message modulation atsc3: %d", modulation.atsc3());
            break;
        case FrontendModulation::hidl_discriminator::dvbt:
            ALOGD("[vts] frontend ext1_1 scan message modulation dvbt: %d", modulation.dvbt());
            break;
        default:
            break;
    }
}

void FrontendCallback::tuneTestOnLock(sp<IFrontend>& frontend, FrontendSettings settings,
                                      FrontendSettingsExt1_1 settingsExt1_1) {
    sp<android::hardware::tv::tuner::V1_1::IFrontend> frontend_1_1;
    frontend_1_1 = android::hardware::tv::tuner::V1_1::IFrontend::castFrom(frontend);
    if (frontend_1_1 == nullptr) {
        EXPECT_TRUE(false) << "Couldn't get 1.1 IFrontend from the Hal implementation.";
        return;
    }

    Result result = frontend_1_1->tune_1_1(settings, settingsExt1_1);
    EXPECT_TRUE(result == Result::SUCCESS);

    android::Mutex::Autolock autoLock(mMsgLock);
    while (!mLockMsgReceived) {
        if (-ETIMEDOUT == mLockMsgCondition.waitRelative(mMsgLock, WAIT_TIMEOUT)) {
            EXPECT_TRUE(false) << "Event LOCKED not received within timeout";
            mLockMsgReceived = false;
            return;
        }
    }
    mLockMsgReceived = false;
}

void FrontendCallback::scanTest(sp<IFrontend>& frontend, FrontendConfig config,
                                FrontendScanType type) {
    sp<android::hardware::tv::tuner::V1_1::IFrontend> frontend_1_1;
    frontend_1_1 = android::hardware::tv::tuner::V1_1::IFrontend::castFrom(frontend);
    if (frontend_1_1 == nullptr) {
        EXPECT_TRUE(false) << "Couldn't get 1.1 IFrontend from the Hal implementation.";
        return;
    }

    uint32_t targetFrequency = getTargetFrequency(config.settings, config.type);
    if (type == FrontendScanType::SCAN_BLIND) {
        // reset the frequency in the scan configuration to test blind scan. The settings param of
        // passed in means the real input config on the transponder connected to the DUT.
        // We want the blind the test to start from lower frequency than this to check the blind
        // scan implementation.
        resetBlindScanStartingFrequency(config, targetFrequency - 100);
    }

    Result result = frontend_1_1->scan_1_1(config.settings, type, config.settingsExt1_1);
    EXPECT_TRUE(result == Result::SUCCESS);

    bool scanMsgLockedReceived = false;
    bool targetFrequencyReceived = false;

    android::Mutex::Autolock autoLock(mMsgLock);
wait:
    while (!mScanMessageReceived) {
        if (-ETIMEDOUT == mMsgCondition.waitRelative(mMsgLock, WAIT_TIMEOUT)) {
            EXPECT_TRUE(false) << "Scan message not received within timeout";
            mScanMessageReceived = false;
            mScanMsgProcessed = true;
            return;
        }
    }

    if (mScanMessageType != FrontendScanMessageType::END) {
        if (mScanMessageType == FrontendScanMessageType::LOCKED) {
            scanMsgLockedReceived = true;
            Result result = frontend_1_1->scan_1_1(config.settings, type, config.settingsExt1_1);
            EXPECT_TRUE(result == Result::SUCCESS);
        }

        if (mScanMessageType == FrontendScanMessageType::FREQUENCY) {
            targetFrequencyReceived = mScanMessage.frequencies().size() > 0 &&
                                      mScanMessage.frequencies()[0] == targetFrequency;
        }

        if (mScanMessageType == FrontendScanMessageType::PROGRESS_PERCENT) {
            ALOGD("[vts] Scan in progress...[%d%%]", mScanMessage.progressPercent());
        }

        mScanMessageReceived = false;
        mScanMsgProcessed = true;
        mMsgCondition.signal();
        goto wait;
    }

    EXPECT_TRUE(scanMsgLockedReceived) << "Scan message LOCKED not received before END";
    EXPECT_TRUE(targetFrequencyReceived) << "frequency not received before LOCKED on blindScan";
    mScanMessageReceived = false;
    mScanMsgProcessed = true;
}

uint32_t FrontendCallback::getTargetFrequency(FrontendSettings settings, FrontendType type) {
    switch (type) {
        case FrontendType::ANALOG:
            return settings.analog().frequency;
        case FrontendType::ATSC:
            return settings.atsc().frequency;
        case FrontendType::ATSC3:
            return settings.atsc3().frequency;
        case FrontendType::DVBC:
            return settings.dvbc().frequency;
        case FrontendType::DVBS:
            return settings.dvbs().frequency;
        case FrontendType::DVBT:
            return settings.dvbt().frequency;
        case FrontendType::ISDBS:
            return settings.isdbs().frequency;
        case FrontendType::ISDBS3:
            return settings.isdbs3().frequency;
        case FrontendType::ISDBT:
            return settings.isdbt().frequency;
        default:
            return 0;
    }
}

void FrontendCallback::resetBlindScanStartingFrequency(FrontendConfig& config,
                                                       uint32_t resetingFreq) {
    switch (config.type) {
        case FrontendType::ANALOG:
            config.settings.analog().frequency = resetingFreq;
            break;
        case FrontendType::ATSC:
            config.settings.atsc().frequency = resetingFreq;
            break;
        case FrontendType::ATSC3:
            config.settings.atsc3().frequency = resetingFreq;
            break;
        case FrontendType::DVBC:
            config.settings.dvbc().frequency = resetingFreq;
            break;
        case FrontendType::DVBS:
            config.settings.dvbs().frequency = resetingFreq;
            break;
        case FrontendType::DVBT:
            config.settings.dvbt().frequency = resetingFreq;
            break;
        case FrontendType::ISDBS:
            config.settings.isdbs().frequency = resetingFreq;
            break;
        case FrontendType::ISDBS3:
            config.settings.isdbs3().frequency = resetingFreq;
            break;
        case FrontendType::ISDBT:
            config.settings.isdbt().frequency = resetingFreq;
            break;
        default:
            // do nothing
            return;
    }
}

AssertionResult FrontendTests::getFrontendIds() {
    Result status;
    mService->getFrontendIds([&](Result result, const hidl_vec<FrontendId>& frontendIds) {
        status = result;
        mFeIds = frontendIds;
    });
    return AssertionResult(status == Result::SUCCESS);
}

AssertionResult FrontendTests::getFrontendInfo(uint32_t frontendId) {
    Result status;
    mService->getFrontendInfo(frontendId, [&](Result result, const FrontendInfo& frontendInfo) {
        mFrontendInfo = frontendInfo;
        status = result;
    });
    return AssertionResult(status == Result::SUCCESS);
}

AssertionResult FrontendTests::openFrontendById(uint32_t frontendId) {
    Result status;
    mService->openFrontendById(frontendId, [&](Result result, const sp<IFrontend>& frontend) {
        mFrontend = frontend;
        status = result;
    });
    return AssertionResult(status == Result::SUCCESS);
}

AssertionResult FrontendTests::setFrontendCallback() {
    EXPECT_TRUE(mFrontend) << "Test with openFrontendById first.";
    mFrontendCallback = new FrontendCallback();
    auto callbackStatus = mFrontend->setCallback(mFrontendCallback);
    return AssertionResult(callbackStatus.isOk());
}

AssertionResult FrontendTests::scanFrontend(FrontendConfig config, FrontendScanType type) {
    EXPECT_TRUE(mFrontendCallback)
            << "test with openFrontendById/setFrontendCallback/getFrontendInfo first.";

    EXPECT_TRUE(mFrontendInfo.type == config.type)
            << "FrontendConfig does not match the frontend info of the given id.";

    mFrontendCallback->scanTest(mFrontend, config, type);
    return AssertionResult(true);
}

AssertionResult FrontendTests::stopScanFrontend() {
    EXPECT_TRUE(mFrontend) << "Test with openFrontendById first.";
    Result status;
    status = mFrontend->stopScan();

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

AssertionResult FrontendTests::getFrontendDtmbCaps(uint32_t id) {
    Result status;
    mService->getFrontendDtmbCapabilities(
            id, [&](Result result, const FrontendDtmbCapabilities& /*caps*/) { status = result; });
    return AssertionResult(status == Result::SUCCESS);
}

void FrontendTests::verifyFrontendStatusExt1_1(vector<FrontendStatusTypeExt1_1> statusTypes,
                                               vector<FrontendStatusExt1_1> expectStatuses) {
    ASSERT_TRUE(mFrontend) << "Frontend is not opened yet.";
    Result status;
    vector<FrontendStatusExt1_1> realStatuses;

    sp<android::hardware::tv::tuner::V1_1::IFrontend> frontend_1_1;
    frontend_1_1 = android::hardware::tv::tuner::V1_1::IFrontend::castFrom(mFrontend);
    if (frontend_1_1 == nullptr) {
        EXPECT_TRUE(false) << "Couldn't get 1.1 IFrontend from the Hal implementation.";
        return;
    }

    frontend_1_1->getStatusExt1_1(
            statusTypes, [&](Result result, const hidl_vec<FrontendStatusExt1_1>& statuses) {
                status = result;
                realStatuses = statuses;
            });

    ASSERT_TRUE(realStatuses.size() == statusTypes.size());
    for (int i = 0; i < statusTypes.size(); i++) {
        FrontendStatusTypeExt1_1 type = statusTypes[i];
        switch (type) {
            case FrontendStatusTypeExt1_1::MODULATIONS: {
                // TODO: verify modulations
                break;
            }
            case FrontendStatusTypeExt1_1::BERS: {
                ASSERT_TRUE(std::equal(realStatuses[i].bers().begin(), realStatuses[i].bers().end(),
                                       expectStatuses[i].bers().begin()));
                break;
            }
            case FrontendStatusTypeExt1_1::CODERATES: {
                ASSERT_TRUE(std::equal(realStatuses[i].codeRates().begin(),
                                       realStatuses[i].codeRates().end(),
                                       expectStatuses[i].codeRates().begin()));
                break;
            }
            case FrontendStatusTypeExt1_1::GUARD_INTERVAL: {
                // TODO: verify interval
                break;
            }
            case FrontendStatusTypeExt1_1::TRANSMISSION_MODE: {
                // TODO: verify tranmission mode
                break;
            }
            case FrontendStatusTypeExt1_1::UEC: {
                ASSERT_TRUE(realStatuses[i].uec() == expectStatuses[i].uec());
                break;
            }
            case FrontendStatusTypeExt1_1::T2_SYSTEM_ID: {
                ASSERT_TRUE(realStatuses[i].systemId() == expectStatuses[i].systemId());
                break;
            }
            case FrontendStatusTypeExt1_1::INTERLEAVINGS: {
                ASSERT_TRUE(std::equal(realStatuses[i].interleaving().begin(),
                                       realStatuses[i].interleaving().end(),
                                       expectStatuses[i].interleaving().begin()));
                break;
            }
            case FrontendStatusTypeExt1_1::ISDBT_SEGMENTS: {
                ASSERT_TRUE(std::equal(realStatuses[i].isdbtSegment().begin(),
                                       realStatuses[i].isdbtSegment().end(),
                                       expectStatuses[i].isdbtSegment().begin()));
                break;
            }
            case FrontendStatusTypeExt1_1::TS_DATA_RATES: {
                ASSERT_TRUE(std::equal(realStatuses[i].tsDataRate().begin(),
                                       realStatuses[i].tsDataRate().end(),
                                       expectStatuses[i].tsDataRate().begin()));
                break;
            }
            case FrontendStatusTypeExt1_1::ROLL_OFF: {
                // TODO: verify roll off
                break;
            }
            case FrontendStatusTypeExt1_1::IS_MISO: {
                ASSERT_TRUE(realStatuses[i].isMiso() == expectStatuses[i].isMiso());
                break;
            }
            case FrontendStatusTypeExt1_1::IS_LINEAR: {
                ASSERT_TRUE(realStatuses[i].isLinear() == expectStatuses[i].isLinear());
                break;
            }
            case FrontendStatusTypeExt1_1::IS_SHORT_FRAMES: {
                ASSERT_TRUE(realStatuses[i].isShortFrames() == expectStatuses[i].isShortFrames());
                break;
            }
            default: {
                continue;
            }
        }
    }
    ASSERT_TRUE(status == Result::SUCCESS);
}

AssertionResult FrontendTests::tuneFrontend(FrontendConfig config, bool testWithDemux) {
    EXPECT_TRUE(mFrontendCallback)
            << "test with openFrontendById/setFrontendCallback/getFrontendInfo first.";

    EXPECT_TRUE(mFrontendInfo.type == config.type)
            << "FrontendConfig does not match the frontend info of the given id.";

    mIsSoftwareFe = config.isSoftwareFe;
    bool result = true;
    if (mIsSoftwareFe && testWithDemux) {
        result &= mDvrTests.openDvrInDemux(mDvrConfig.type, mDvrConfig.bufferSize) == success();
        result &= mDvrTests.configDvrPlayback(mDvrConfig.settings) == success();
        result &= mDvrTests.getDvrPlaybackMQDescriptor() == success();
        mDvrTests.startPlaybackInputThread(mDvrConfig.playbackInputFile,
                                           mDvrConfig.settings.playback());
        if (!result) {
            ALOGW("[vts] Software frontend dvr configure failed.");
            return failure();
        }
    }
    mFrontendCallback->tuneTestOnLock(mFrontend, config.settings, config.settingsExt1_1);
    return AssertionResult(true);
}

AssertionResult FrontendTests::stopTuneFrontend(bool testWithDemux) {
    EXPECT_TRUE(mFrontend) << "Test with openFrontendById first.";
    Result status;
    status = mFrontend->stopTune();
    if (mIsSoftwareFe && testWithDemux) {
        mDvrTests.stopPlaybackThread();
        mDvrTests.closeDvrPlayback();
    }
    return AssertionResult(status == Result::SUCCESS);
}

AssertionResult FrontendTests::closeFrontend() {
    EXPECT_TRUE(mFrontend) << "Test with openFrontendById first.";
    Result status;
    status = mFrontend->close();
    mFrontend = nullptr;
    mFrontendCallback = nullptr;
    return AssertionResult(status == Result::SUCCESS);
}

void FrontendTests::getFrontendIdByType(FrontendType feType, uint32_t& feId) {
    ASSERT_TRUE(getFrontendIds());
    ASSERT_TRUE(mFeIds.size() > 0);
    for (size_t i = 0; i < mFeIds.size(); i++) {
        ASSERT_TRUE(getFrontendInfo(mFeIds[i]));
        if (mFrontendInfo.type != feType) {
            continue;
        }
        feId = mFeIds[i];
        return;
    }
    feId = INVALID_ID;
}

void FrontendTests::tuneTest(FrontendConfig frontendConf) {
    uint32_t feId;
    getFrontendIdByType(frontendConf.type, feId);
    ASSERT_TRUE(feId != INVALID_ID);
    ASSERT_TRUE(openFrontendById(feId));
    ASSERT_TRUE(setFrontendCallback());
    ASSERT_TRUE(tuneFrontend(frontendConf, false /*testWithDemux*/));
    verifyFrontendStatusExt1_1(frontendConf.tuneStatusTypes, frontendConf.expectTuneStatuses);
    ASSERT_TRUE(stopTuneFrontend(false /*testWithDemux*/));
    ASSERT_TRUE(closeFrontend());
}

void FrontendTests::scanTest(FrontendConfig frontendConf, FrontendScanType scanType) {
    uint32_t feId;
    getFrontendIdByType(frontendConf.type, feId);
    ASSERT_TRUE(feId != INVALID_ID);
    ASSERT_TRUE(openFrontendById(feId));
    ASSERT_TRUE(setFrontendCallback());
    ASSERT_TRUE(scanFrontend(frontendConf, scanType));
    ASSERT_TRUE(stopScanFrontend());
    ASSERT_TRUE(closeFrontend());
}

void FrontendTests::getFrontendDtmbCapsTest() {
    uint32_t feId;
    getFrontendIdByType(
            static_cast<FrontendType>(android::hardware::tv::tuner::V1_1::FrontendType::DTMB),
            feId);
    if (feId != INVALID_ID) {
        ALOGD("[vts] Found DTMB Frontend");
        ASSERT_TRUE(getFrontendDtmbCaps(feId));
    }
}