Merge "media.omx VTS test baseline" into oc-dev am: 9eeda956

subdirs = [

    "1.0",

    "omx/1.0",

	"omx/1.0/vts/functional/master",

	"omx/1.0/vts/functional/component",

	"omx/1.0/vts/functional/audio",

]

//

// Copyright (C) 2017 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: "VtsHalMediaOmxV1_0TargetAudioEncTest",

    defaults: ["hidl_defaults"],

    srcs: ["VtsHalMediaOmxV1_0TargetAudioEncTest.cpp",

           "media_audio_hidl_test_common.cpp"],

    shared_libs: [

        "libbase",

        "liblog",

        "libcutils",

        "libhidlbase",

        "libhidlmemory",

        "libhidltransport",

        "libhwbinder",

        "libnativehelper",

        "libutils",

        "libstagefright_foundation",

        "android.hidl.allocator@1.0",

        "android.hidl.memory@1.0",

        "android.hardware.media.omx@1.0",

    ],

    static_libs: ["VtsHalHidlTargetTestBase"],

    cflags: [

        "-O0",

        "-g",

    ],

    include_dirs: [

        "frameworks/native/include/media/openmax/",

        "hardware/interfaces/media/omx/1.0/vts/functional/common",

    ],

}

cc_test {

    name: "VtsHalMediaOmxV1_0TargetAudioDecTest",

    defaults: ["hidl_defaults"],

    srcs: ["VtsHalMediaOmxV1_0TargetAudioDecTest.cpp",

           "media_audio_hidl_test_common.cpp"],

    shared_libs: [

        "libbase",

        "liblog",

        "libcutils",

        "libhidlbase",

        "libhidlmemory",

        "libhidltransport",

        "libhwbinder",

        "libnativehelper",

        "libutils",

        "libstagefright_foundation",

        "android.hidl.allocator@1.0",

        "android.hidl.memory@1.0",

        "android.hardware.media.omx@1.0",

    ],

    static_libs: ["VtsHalHidlTargetTestBase"],

    cflags: [

        "-O0",

        "-g",

    ],

    include_dirs: [

        "frameworks/native/include/media/openmax/",

        "hardware/interfaces/media/omx/1.0/vts/functional/common",

    ],

}

/*

 * Copyright (C) 2017 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 "media_omx_hidl_audio_enc_test"

#include <android-base/logging.h>

#include <android/hardware/media/omx/1.0/IOmx.h>

#include <android/hardware/media/omx/1.0/IOmxNode.h>

#include <android/hardware/media/omx/1.0/IOmxObserver.h>

#include <android/hardware/media/omx/1.0/types.h>

#include <android/hidl/allocator/1.0/IAllocator.h>

#include <android/hidl/memory/1.0/IMapper.h>

#include <android/hidl/memory/1.0/IMemory.h>

using ::android::hardware::media::omx::V1_0::IOmx;

using ::android::hardware::media::omx::V1_0::IOmxObserver;

using ::android::hardware::media::omx::V1_0::IOmxNode;

using ::android::hardware::media::omx::V1_0::Message;

using ::android::hardware::media::omx::V1_0::CodecBuffer;

using ::android::hidl::allocator::V1_0::IAllocator;

using ::android::hidl::memory::V1_0::IMemory;

using ::android::hidl::memory::V1_0::IMapper;

using ::android::hardware::Return;

using ::android::hardware::Void;

using ::android::hardware::hidl_vec;

using ::android::hardware::hidl_string;

using ::android::sp;

#include <VtsHalHidlTargetTestBase.h>

#include <getopt.h>

#include <media_audio_hidl_test_common.h>

#include <media_hidl_test_common.h>

#include <fstream>

// A class for test environment setup

class ComponentTestEnvironment : public ::testing::Environment {

   public:

    virtual void SetUp() {}

    virtual void TearDown() {}

    ComponentTestEnvironment() : instance("default") {}

    void setInstance(const char* _instance) { instance = _instance; }

    void setComponent(const char* _component) { component = _component; }

    void setRole(const char* _role) { role = _role; }

    void setQuirks(int _quirks) { quirks = _quirks; }

    const hidl_string getInstance() const { return instance; }

    const hidl_string getComponent() const { return component; }

    const hidl_string getRole() const { return role; }

    int getQuirks() const { return quirks; }

    int initFromOptions(int argc, char** argv) {

        static struct option options[] = {

            {"instance", required_argument, 0, 'I'},

            {"component", required_argument, 0, 'C'},

            {"role", required_argument, 0, 'R'},

            {"quirks", required_argument, 0, 'Q'},

            {0, 0, 0, 0}};

        while (true) {

            int index = 0;

            int c = getopt_long(argc, argv, "I:C:Q:R:", options, &index);

            if (c == -1) {

                break;

            }

            switch (c) {

                case 'I':

                    setInstance(optarg);

                    break;

                case 'C':

                    setComponent(optarg);

                    break;

                case 'Q':

                    setQuirks(atoi(optarg));

                    break;

                case 'R':

                    setRole(optarg);

                    break;

                case '?':

                    break;

            }

        }

        if (optind < argc) {

            fprintf(stderr,

                    "unrecognized option: %s\n\n"

                    "usage: %s <gtest options> <test options>\n\n"

                    "test options are:\n\n"

                    "-I, --instance: HAL instance to test\n"

                    "-C, --component: OMX component to test\n"

                    "-R, --Role: OMX component Role\n"

                    "-Q, --quirks: Component quirks\n",

                    argv[optind ?: 1], argv[0]);

            return 2;

        }

        return 0;

    }

   private:

    hidl_string instance;

    hidl_string component;

    hidl_string role;

    // to be removed when IOmxNode::setQuirks is removed

    int quirks;

};

static ComponentTestEnvironment* gEnv = nullptr;

class AudioEncHidlTest : public ::testing::VtsHalHidlTargetTestBase {

   public:

    virtual void SetUp() override {

        android::hardware::media::omx::V1_0::Status status;

        omx = ::testing::VtsHalHidlTargetTestBase::getService<IOmx>(

            gEnv->getInstance());

        ASSERT_NE(omx, nullptr);

        observer = new CodecObserver();

        ASSERT_NE(observer, nullptr);

        ASSERT_EQ(strncmp(gEnv->getComponent().c_str(), "OMX.", 4), 0)

            << "Invalid Component Name";

        EXPECT_TRUE(omx->allocateNode(

                           gEnv->getComponent(), observer,

                           [&](android::hardware::media::omx::V1_0::Status _s,

                               sp<IOmxNode> const& _nl) {

                               status = _s;

                               this->omxNode = _nl;

                           })

                        .isOk());

        ASSERT_NE(omxNode, nullptr);

        ASSERT_NE(gEnv->getRole().empty(), true) << "Invalid Component Role";

        struct StringToName {

            const char* Name;

            standardComp CompName;

        };

        const StringToName kStringToName[] = {

            {"mp3", mp3}, {"amrnb", amrnb},   {"amrwb", amrwb},

            {"aac", aac}, {"vorbis", vorbis}, {"opus", opus},

            {"pcm", pcm}, {"flac", flac},

        };

        const size_t kNumStringToName =

            sizeof(kStringToName) / sizeof(kStringToName[0]);

        const char* pch;

        char substring[OMX_MAX_STRINGNAME_SIZE];

        strcpy(substring, gEnv->getRole().c_str());

        pch = strchr(substring, '.');

        ASSERT_NE(pch, nullptr);

        compName = unknown_comp;

        for (size_t i = 0; i < kNumStringToName; ++i) {

            if (!strcasecmp(pch + 1, kStringToName[i].Name)) {

                compName = kStringToName[i].CompName;

                break;

            }

        }

        ASSERT_NE(compName, unknown_comp);

        struct CompToCoding {

            standardComp CompName;

            OMX_AUDIO_CODINGTYPE eEncoding;

        };

        static const CompToCoding kCompToCoding[] = {

            {mp3, OMX_AUDIO_CodingMP3},

            {amrnb, OMX_AUDIO_CodingAMR},

            {amrwb, OMX_AUDIO_CodingAMR},

            {aac, OMX_AUDIO_CodingAAC},

            {vorbis, OMX_AUDIO_CodingVORBIS},

            {pcm, OMX_AUDIO_CodingPCM},

            {opus, (OMX_AUDIO_CODINGTYPE)OMX_AUDIO_CodingAndroidOPUS},

            {flac, OMX_AUDIO_CodingFLAC},

        };

        static const size_t kNumCompToCoding =

            sizeof(kCompToCoding) / sizeof(kCompToCoding[0]);

        size_t i;

        for (i = 0; i < kNumCompToCoding; ++i) {

            if (kCompToCoding[i].CompName == compName) {

                eEncoding = kCompToCoding[i].eEncoding;

                break;

            }

        }

        ASSERT_NE(i, kNumCompToCoding);

    }

    virtual void TearDown() override {

        if (omxNode != nullptr) {

            EXPECT_TRUE((omxNode->freeNode()).isOk());

            omxNode = nullptr;

        }

    }

    enum standardComp {

        mp3,

        amrnb,

        amrwb,

        aac,

        vorbis,

        opus,

        pcm,

        flac,

        unknown_comp,

    };

    sp<IOmx> omx;

    sp<CodecObserver> observer;

    sp<IOmxNode> omxNode;

    standardComp compName;

    OMX_AUDIO_CODINGTYPE eEncoding;

};

// Set Component Role

TEST_F(AudioEncHidlTest, SetRole) {

    android::hardware::media::omx::V1_0::Status status;

    status = setRole(omxNode, gEnv->getRole().c_str());

    ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);

}

// Enumerate Port Format

TEST_F(AudioEncHidlTest, EnumeratePortFormat) {

    android::hardware::media::omx::V1_0::Status status;

    uint32_t kPortIndexInput = 0, kPortIndexOutput = 1;

    status = setRole(omxNode, gEnv->getRole().c_str());

    ASSERT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);

    OMX_PORT_PARAM_TYPE params;

    status = getParam(omxNode, OMX_IndexParamAudioInit, &params);

    if (status == ::android::hardware::media::omx::V1_0::Status::OK) {

        ASSERT_EQ(params.nPorts, 2U);

        kPortIndexInput = params.nStartPortNumber;

        kPortIndexOutput = kPortIndexInput + 1;

    }

    status = setAudioPortFormat(omxNode, kPortIndexInput, OMX_AUDIO_CodingPCM);

    EXPECT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);

    status = setAudioPortFormat(omxNode, kPortIndexOutput, eEncoding);

    EXPECT_EQ(status, ::android::hardware::media::omx::V1_0::Status::OK);

}

int main(int argc, char** argv) {

    gEnv = new ComponentTestEnvironment();

    ::testing::AddGlobalTestEnvironment(gEnv);

    ::testing::InitGoogleTest(&argc, argv);

    int status = gEnv->initFromOptions(argc, argv);

    if (status == 0) {

        status = RUN_ALL_TESTS();

        ALOGI("Test result = %d", status);

    }

    return status;

}