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

Commit 4f5188ae authored by Haoxiang Li's avatar Haoxiang Li
Browse files

[SV HIDL] VTS Test for Surround View

Bug: 148618804

Test: atest -c VtsHalSurroundViewV1_0TargetTest

Change-Id: I1c6bfa77adb699ab80337497aac4582861315bcd
parent a4a81e38
Loading
Loading
Loading
Loading
+41 −0
Original line number Diff line number Diff line
//
// Copyright (C) 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.
//

cc_test {
    name: "VtsHalSurroundViewV1_0TargetTest",
    srcs: [
        "VtsHalSurroundViewV1_0TargetTest.cpp",
        "SurroundViewStreamHandler.cpp",
    ],
    defaults: ["VtsHalTargetTestDefaults"],
    static_libs: [
        "libnativewindow",
        "android.hardware.automotive.sv@1.0",
        "android.hardware.graphics.common@1.0",
        "android.hardware.graphics.common@1.1",
        "android.hardware.graphics.common@1.2",
    ],
    shared_libs: [
        "android.hidl.allocator@1.0",
        "android.hidl.memory@1.0",
        "libhidlmemory",
    ],
    test_suites: ["general-tests", "vts-core"],
    cflags: [
        "-O0",
        "-g",
    ],
}
+113 −0
Original line number Diff line number Diff line
/*
 * Copyright (C) 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 "SurroundViewStreamHandler.h"

#include <utils/Log.h>

using std::lock_guard;

SurroundViewServiceHandler::SurroundViewServiceHandler(sp<ISurroundViewSession> pSession) :
    mSession(pSession),
    mReceiveFramesCount(0),
    mDoNotReturnFrames(false) {
    // Nothing but member initialization
}

Return<void> SurroundViewServiceHandler::notify(SvEvent svEvent) {
    ALOGD("SurroundViewServiceHandler::notify %d", svEvent);

    lock_guard<mutex> lock(mLock);
    switch (svEvent) {
        case SvEvent::STREAM_STARTED:
        case SvEvent::CONFIG_UPDATED:
        case SvEvent::STREAM_STOPPED:
        case SvEvent::FRAME_DROPPED:
        case SvEvent::TIMEOUT:
            mReceivedEvents.emplace_back(svEvent);
            break;
        default:
            ALOGI("[SurroundViewLog] Received other event");
    }

    return android::hardware::Void();
}

Return<void> SurroundViewServiceHandler::receiveFrames(const SvFramesDesc& svFramesDesc) {
    ALOGD("SurroundViewServiceHandler::receiveFrames");

    lock_guard<mutex> lock(mLock);
    unsigned long timestampNs = svFramesDesc.timestampNs;
    unsigned sequenceId = svFramesDesc.sequenceId;
    ALOGD("receiveFrames count: %d", mReceiveFramesCount);
    ALOGD("timestampNs: %lu, sequenceId: %u", timestampNs, sequenceId);
    if (mReceiveFramesCount != 0
        && (mLastReceivedFrames.timestampNs >= svFramesDesc.timestampNs
            || mLastReceivedFrames.sequenceId >= svFramesDesc.sequenceId)) {
        mAllFramesValid = false;
        ALOGD("The incoming frames are with invalid timestamp or sequenceId!");
    }

    for (int i=0; i<svFramesDesc.svBuffers.size(); i++) {
        if (svFramesDesc.svBuffers[i].hardwareBuffer.nativeHandle == nullptr) {
            mAllFramesValid = false;
            ALOGD("The incoming frames are with invalid nativeHandle!");
            break;
        }
    }

    mReceiveFramesCount++;

    // Store all the information except for the handle
    mLastReceivedFrames.timestampNs = svFramesDesc.timestampNs;
    mLastReceivedFrames.sequenceId = svFramesDesc.sequenceId;
    mLastReceivedFrames.svBuffers.resize(svFramesDesc.svBuffers.size());
    for (int i=0; i<svFramesDesc.svBuffers.size(); i++) {
        mLastReceivedFrames.svBuffers[i].viewId = svFramesDesc.svBuffers[i].viewId;
        mLastReceivedFrames.svBuffers[i].hardwareBuffer.description =
            svFramesDesc.svBuffers[i].hardwareBuffer.description;
    }

    if (!mDoNotReturnFrames) {
        mSession->doneWithFrames(svFramesDesc);
    }

    return android::hardware::Void();
}

bool SurroundViewServiceHandler::checkEventReceived(SvEvent svEvent) {
    ALOGD("SurroundViewServiceHandler::checkEventReceived");
    int size = mReceivedEvents.size(); // work around
    ALOGD("Received event number: %d", size);
    auto iter = find(mReceivedEvents.begin(), mReceivedEvents.end(), svEvent);
    return iter != mReceivedEvents.end();
}

SvFramesDesc SurroundViewServiceHandler::getLastReceivedFrames() {
    return mLastReceivedFrames;
}

int SurroundViewServiceHandler::getReceiveFramesCount() {
    return mReceiveFramesCount;
}

bool SurroundViewServiceHandler::areAllFramesValid() {
    return mAllFramesValid;
}

void SurroundViewServiceHandler::setDoNotReturnFrames(bool flag) {
    mDoNotReturnFrames = flag;
}
+57 −0
Original line number Diff line number Diff line
/*
 * Copyright (C) 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.
 */

#ifndef SURROUND_VIEW_STREAM_HANDLER_H
#define SURROUND_VIEW_STREAM_HANDLER_H

#include <android/hardware/automotive/sv/1.0/types.h>
#include <android/hardware/automotive/sv/1.0/ISurroundViewStream.h>
#include <android/hardware/automotive/sv/1.0/ISurroundViewSession.h>

#include <thread>
#include <vector>

using std::vector;
using std::mutex;
using android::hardware::Return;
using android::sp;
using namespace ::android::hardware::automotive::sv::V1_0;

class SurroundViewServiceHandler : public ISurroundViewStream {
public:
    SurroundViewServiceHandler(sp<ISurroundViewSession> session);

    Return<void> notify(SvEvent svEvent) override;
    Return<void> receiveFrames(const SvFramesDesc& svFramesDesc) override;

    bool checkEventReceived(SvEvent svEvent);
    SvFramesDesc getLastReceivedFrames();
    int getReceiveFramesCount();
    bool areAllFramesValid();
    void setDoNotReturnFrames(bool flag);

private:
    mutex mLock;

    vector<SvEvent> mReceivedEvents;
    sp<ISurroundViewSession> mSession;
    SvFramesDesc mLastReceivedFrames; // only use timestampNs and sequenceId
    int mReceiveFramesCount; // TODO(haoxiangl): figure out a better name
    bool mAllFramesValid = true;
    bool mDoNotReturnFrames;
};

#endif //SURROUND_VIEW_STREAM_HANDLER_H
+1137 −0

File added.

Preview size limit exceeded, changes collapsed.