xref: /foundation/multimedia/av_codec/test/moduletest/audio_encoder/NativeAPI/NativeFunctionTest.cpp

/*
 * Copyright (C) 2022 Huawei Device Co., Ltd.
 * 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 <string>
#include "gtest/gtest.h"
#include "AudioEncoderDemoCommon.h"

using namespace std;
using namespace testing::ext;
using namespace OHOS;
using namespace OHOS::MediaAVCodec;


namespace {
    class NativeFunctionTest : public testing::Test {
    public:
        static void SetUpTestCase();
        static void TearDownTestCase();
        void SetUp() override;
        void TearDown() override;
    };

    void NativeFunctionTest::SetUpTestCase() {}
    void NativeFunctionTest::TearDownTestCase() {}
    void NativeFunctionTest::SetUp() {}
    void NativeFunctionTest::TearDown() {}

    constexpr uint32_t DEFAULT_AAC_TYPE = 1;
    constexpr int32_t CHANNEL_COUNT_AAC = 2;
    constexpr int32_t SAMPLE_RATE_AAC = 16000;
    constexpr int64_t BITS_RATE_AAC = 129000;
    constexpr int32_t CHANNEL_COUNT_FLAC = 2;
    constexpr int32_t SAMPLE_RATE_FLAC = 48000;
    constexpr int64_t BITS_RATE_FLAC = 128000;
    constexpr int32_t COMPLIANCE_LEVEL = -2;

    constexpr int32_t CHANNEL_COUNT_MONO = 1;
    constexpr int32_t CHANNEL_COUNT_STEREO = 2;
    constexpr int32_t CHANNEL_COUNT_7POINT1 = 8;

    int32_t testResult[16] = { -1 };

    vector<string> SplitStringFully(const string& str, const string& separator)
    {
        vector<string> dest;
        string substring;
        string::size_type start = 0;
        string::size_type index = str.find_first_of(separator, start);

        while (index != string::npos) {
            substring = str.substr(start, index - start);
            dest.push_back(substring);
            start = str.find_first_not_of(separator, index);
            if (start == string::npos) {
                return dest;
            }

            index = str.find_first_of(separator, start);
        }
        substring = str.substr(start);
        dest.push_back(substring);

        return dest;
    }

    bool compareFile(string file1, string file2)
    {
        string ans1, ans2;
        int i;
        (void)freopen(file1.c_str(), "r", stdin);
        char c;
        while (scanf_s("%c", &c, 1) != EOF) {
            ans1 += c;
        }
        (void)fclose(stdin);

        (void)freopen(file2.c_str(), "r", stdin);
        while (scanf_s("%c", &c, 1) != EOF) {
            ans2 += c;
        }
        (void)fclose(stdin);
        if (ans1.size() != ans2.size()) {
            return false;
        }
        for (i = 0; i < ans1.size(); i++) {
            if (ans1[i] != ans2[i]) {
                return false;
            }
        }
        return true;
    }

    OH_AVFormat* getAVFormatByEncoder(string encoderName)
    {
        OH_AVFormat* format = OH_AVFormat_Create();
        if (encoderName == "OH.Media.Codec.Encoder.Audio.AAC") {
            OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, CHANNEL_COUNT_AAC);
            OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, SAMPLE_RATE_AAC);
            OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, OH_BitsPerSample::SAMPLE_F32LE);
            OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, OH_BitsPerSample::SAMPLE_F32LE);
            OH_AVFormat_SetLongValue(format, OH_MD_KEY_CHANNEL_LAYOUT, STEREO);
            OH_AVFormat_SetIntValue(format, OH_MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_TYPE);
            OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, BITS_RATE_AAC);
        } else {
            OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, CHANNEL_COUNT_FLAC);
            OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, SAMPLE_RATE_FLAC);
            OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, OH_BitsPerSample::SAMPLE_S16LE);
            OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, OH_BitsPerSample::SAMPLE_S16LE);
            OH_AVFormat_SetLongValue(format, OH_MD_KEY_CHANNEL_LAYOUT, STEREO);
            OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, BITS_RATE_FLAC);
        }
        return format;
    }

    void runEncode(string encoderName, string inputFile, string outputFile, int32_t threadId)
    {
        AudioEncoderDemo* encoderDemo = new AudioEncoderDemo();

        OH_AVFormat* format = getAVFormatByEncoder(encoderName);

        encoderDemo->NativeRunCase(inputFile, outputFile, encoderName.c_str(), format);

        OH_AVFormat_Destroy(format);
        delete encoderDemo;

        testResult[threadId] = AV_ERR_OK;
    }

    OH_AVFormat* getAVFormatAAC(int32_t channelCount, int32_t sampleRate, int64_t bitrate)
    {
        OH_AVFormat* format = OH_AVFormat_Create();
        OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, channelCount);
        OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, sampleRate);
        OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, OH_BitsPerSample::SAMPLE_F32LE);
        OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, OH_BitsPerSample::SAMPLE_F32LE);

        switch (channelCount) {
            case CHANNEL_COUNT_MONO:
                OH_AVFormat_SetLongValue(format, OH_MD_KEY_CHANNEL_LAYOUT, MONO);
                break;
            case CHANNEL_COUNT_STEREO:
                OH_AVFormat_SetLongValue(format, OH_MD_KEY_CHANNEL_LAYOUT, STEREO);
                break;
            case CHANNEL_COUNT_7POINT1:
                OH_AVFormat_SetLongValue(format, OH_MD_KEY_CHANNEL_LAYOUT, CH_7POINT1);
                break;
            default:
                OH_AVFormat_SetLongValue(format, OH_MD_KEY_CHANNEL_LAYOUT, UNKNOWN_CHANNEL_LAYOUT);
                break;
        }

        OH_AVFormat_SetIntValue(format, OH_MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_TYPE);
        OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, bitrate);

        return format;
    }


    OH_AVFormat* getAVFormatFlac(int32_t channelCount, int32_t sampleRate, int32_t sampleFormat, int64_t bitrate)
    {
        OH_AVFormat* format = OH_AVFormat_Create();
        OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, channelCount);
        OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, sampleRate);
        OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, sampleFormat);
        OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, sampleFormat);

        int32_t bitsPerSample;
        if (sampleFormat == OH_BitsPerSample::SAMPLE_S16LE) {
            bitsPerSample = S16_BITS_PER_SAMPLE;
        } else {
            bitsPerSample = S32_BITS_PER_SAMPLE;
        }

        int32_t inputBufSize;
        switch (channelCount) {
            case CHANNEL_COUNT_MONO:
                OH_AVFormat_SetLongValue(format, OH_MD_KEY_CHANNEL_LAYOUT, MONO);
                inputBufSize = COMMON_FLAC_NUM * channelCount * bitsPerSample;
                break;
            case CHANNEL_COUNT_STEREO:
                OH_AVFormat_SetLongValue(format, OH_MD_KEY_CHANNEL_LAYOUT, STEREO);
                inputBufSize = COMMON_FLAC_NUM * channelCount * bitsPerSample;
                break;
            case CHANNEL_COUNT_7POINT1:
                OH_AVFormat_SetLongValue(format, OH_MD_KEY_CHANNEL_LAYOUT, CH_7POINT1);
                inputBufSize = COMMON_FLAC_NUM * channelCount * bitsPerSample;
                break;
            default:
                OH_AVFormat_SetLongValue(format, OH_MD_KEY_CHANNEL_LAYOUT, UNKNOWN_CHANNEL_LAYOUT);
                inputBufSize = COMMON_FLAC_NUM * UNKNOWN_CHANNEL * bitsPerSample;
                break;
        }

        OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, bitrate);
        OH_AVFormat_SetIntValue(format, OH_MD_KEY_COMPLIANCE_LEVEL, COMPLIANCE_LEVEL);
        OH_AVFormat_SetIntValue(format, OH_MD_KEY_MAX_INPUT_SIZE, inputBufSize);

        return format;
    }
}

/**
 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_FUNCTION_001
 * @tc.name      : aac(different sample rate)
 * @tc.desc      : function check
 */
HWTEST_F(NativeFunctionTest, SUB_MULTIMEDIA_AUDIO_ENCODER_FUNCTION_001, TestSize.Level2)
{
    AudioEncoderDemo* encoderDemo = new AudioEncoderDemo();
    string encoderName = "OH.Media.Codec.Encoder.Audio.AAC";

    string fileList[] = {
        "f32le_7350_2_dayuhaitang.pcm",
        "f32le_16000_2_dayuhaitang.pcm",
        "f32le_44100_2_dayuhaitang.pcm",
        "f32le_48000_2_dayuhaitang.pcm",
        "f32le_96000_2_dayuhaitang.pcm"
    };

    for (int i = 0; i < 5; i++)
    {
        vector<string> dest = SplitStringFully(fileList[i], "_");
        if (dest.size() < 4) {
            cout << "split error !!!" << endl;
            return;
        }
        int32_t channelCount = stoi(dest[2]);
        int32_t sampleRate = stoi(dest[1]);

        cout << "channel count is " << channelCount << ", sample rate is " << sampleRate << endl;

        OH_AVFormat* format = getAVFormatAAC(channelCount, sampleRate, BITS_RATE_AAC);
        ASSERT_NE(nullptr, format);

        string inputFile = fileList[i];
        string outputFile = "FUNCTION_001_" + to_string(sampleRate) + ".aac";

        encoderDemo->NativeRunCase(inputFile, outputFile, encoderName.c_str(), format);

        OH_AVFormat_Destroy(format);
    }
    delete encoderDemo;
}

/**
 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_FUNCTION_002
 * @tc.name      : aac(different channel num)
 * @tc.desc      : function check
 */
HWTEST_F(NativeFunctionTest, SUB_MULTIMEDIA_AUDIO_ENCODER_FUNCTION_002, TestSize.Level2)
{
    AudioEncoderDemo* encoderDemo = new AudioEncoderDemo();
    string encoderName = "OH.Media.Codec.Encoder.Audio.AAC";

    string fileList[] = {
        "f32le_7350_1_dayuhaitang.pcm",
        "f32le_16000_2_dayuhaitang.pcm",
        "f32le_96000_8_dayuhaitang.pcm"
    };

    for (int i = 0; i < 3; i++)
    {
        vector<string> dest = SplitStringFully(fileList[i], "_");
        if (dest.size() < 4)
        {
            cout << "split error !!!" << endl;
            return;
        }
        int32_t channelCount = stoi(dest[2]);
        int32_t sampleRate = stoi(dest[1]);

        cout << "channel count is " << channelCount << ", sample rate is " << sampleRate << endl;

        OH_AVFormat* format = getAVFormatAAC(channelCount, sampleRate, BITS_RATE_AAC);
        ASSERT_NE(nullptr, format);

        string inputFile = fileList[i];
        string outputFile = "FUNCTION_002_" + to_string(channelCount) + ".aac";

        encoderDemo->NativeRunCase(inputFile, outputFile, encoderName.c_str(), format);

        OH_AVFormat_Destroy(format);
    }
    delete encoderDemo;
}


/**
 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_FUNCTION_003
 * @tc.name      : aac(different bitrate)
 * @tc.desc      : function check
 */
HWTEST_F(NativeFunctionTest, SUB_MULTIMEDIA_AUDIO_ENCODER_FUNCTION_003, TestSize.Level2)
{
    AudioEncoderDemo* encoderDemo = new AudioEncoderDemo();
    string encoderName = "OH.Media.Codec.Encoder.Audio.AAC";

    long bitrateList[] = {32000L, 96000L, 128000L, 256000L, 300000L, 500000L};
    string inputFile = "f32le_96000_2_dayuhaitang.pcm";

    for (int i = 0; i < 6; i++)
    {
        vector<string> dest = SplitStringFully(inputFile, "_");
        if (dest.size() < 4)
        {
            cout << "split error !!!" << endl;
            return;
        }
        int32_t channelCount = stoi(dest[2]);
        int32_t sampleRate = stoi(dest[1]);

        cout << "channel count is " << channelCount << ", sample rate is " << sampleRate << endl;

        OH_AVFormat* format = getAVFormatAAC(channelCount, sampleRate, bitrateList[i]);
        ASSERT_NE(nullptr, format);

        string outputFile = "FUNCTION_003_" + to_string(bitrateList[i]) + ".aac";

        encoderDemo->NativeRunCase(inputFile, outputFile, encoderName.c_str(), format);

        OH_AVFormat_Destroy(format);
    }
    delete encoderDemo;
}


/**
 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_FUNCTION_004
 * @tc.name      : flac(different sample rate)
 * @tc.desc      : function check
 */
HWTEST_F(NativeFunctionTest, SUB_MULTIMEDIA_AUDIO_ENCODER_FUNCTION_004, TestSize.Level2)
{
    AudioEncoderDemo* encoderDemo = new AudioEncoderDemo();
    string encoderName = "OH.Media.Codec.Encoder.Audio.Flac";

    string fileList[] = {
        "s16_8000_2_dayuhaitang.pcm",
        "s16_16000_2_dayuhaitang.pcm",
        "s16_44100_2_dayuhaitang.pcm",
        "s16_48000_2_dayuhaitang.pcm",
        "s16_96000_2_dayuhaitang.pcm"
    };

    for (int i = 0; i < 5; i++)
    {
        vector<string> dest = SplitStringFully(fileList[i], "_");
        if (dest.size() < 4)
        {
            cout << "split error !!!" << endl;
            return;
        }
        int32_t channelCount = stoi(dest[2]);
        int32_t sampleRate = stoi(dest[1]);

        OH_AVFormat* format = getAVFormatFlac(channelCount, sampleRate, OH_BitsPerSample::SAMPLE_S16LE, BITS_RATE_FLAC);
        ASSERT_NE(nullptr, format);

        string inputFile = fileList[i];
        string outputFile = "FUNCTION_004_" + to_string(sampleRate) + ".flac";

        encoderDemo->NativeRunCase(inputFile, outputFile, encoderName.c_str(), format);

        OH_AVFormat_Destroy(format);
    }
    delete encoderDemo;
}


/**
 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_FUNCTION_005
 * @tc.name      : flac(different sample format)
 * @tc.desc      : function check
 */
HWTEST_F(NativeFunctionTest, SUB_MULTIMEDIA_AUDIO_ENCODER_FUNCTION_005, TestSize.Level2)
{
    AudioEncoderDemo* encoderDemo = new AudioEncoderDemo();
    string encoderName = "OH.Media.Codec.Encoder.Audio.Flac";

    string fileList[] = {
        "s32_8000_2_dayuhaitang.pcm",
        "s32_16000_2_dayuhaitang.pcm",
        "s32_44100_2_dayuhaitang.pcm",
        "s32_48000_2_dayuhaitang.pcm",
        "s32_96000_2_dayuhaitang.pcm"
    };

    long bitrate = 500000;

    for (int i = 0; i < 5; i++)
    {
        vector<string> dest = SplitStringFully(fileList[i], "_");
        if (dest.size() < 4) {
            cout << "split error !!!" << endl;
            return;
        }
        int32_t channelCount = stoi(dest[2]);
        int32_t sampleRate = stoi(dest[1]);

        int32_t sampleFormat;
        if (dest[0] == "s16") {
            sampleFormat = OH_BitsPerSample::SAMPLE_S16LE;
        } else {
            sampleFormat = OH_BitsPerSample::SAMPLE_S32LE;
        }

        OH_AVFormat* format = getAVFormatFlac(channelCount, sampleRate, sampleFormat, bitrate);
        ASSERT_NE(nullptr, format);

        string inputFile = fileList[i];
        string outputFile = "FUNCTION_005_" + dest[0] + "_" + to_string(sampleRate) + ".flac";

        encoderDemo->NativeRunCase(inputFile, outputFile, encoderName.c_str(), format);

        OH_AVFormat_Destroy(format);
    }
    delete encoderDemo;
}


/**
 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_FUNCTION_006
 * @tc.name      : flac(different channel num)
 * @tc.desc      : function check
 */
HWTEST_F(NativeFunctionTest, SUB_MULTIMEDIA_AUDIO_ENCODER_FUNCTION_006, TestSize.Level2)
{
    AudioEncoderDemo* encoderDemo = new AudioEncoderDemo();
    string encoderName = "OH.Media.Codec.Encoder.Audio.Flac";

    string fileList[] = {
        "s16_8000_1_dayuhaitang.pcm",
        "s16_48000_1_dayuhaitang.pcm",
        "s16_48000_2_dayuhaitang.pcm",
        "s16_48000_8_dayuhaitang.pcm"
    };

    long bitrate = 500000;

    for (int i = 0; i < 4; i++)
    {
        vector<string> dest = SplitStringFully(fileList[i], "_");
        if (dest.size() < 4)
        {
            cout << "split error !!!" << endl;
            return;
        }
        int32_t channelCount = stoi(dest[2]);
        int32_t sampleRate = stoi(dest[1]);

        int32_t sampleFormat;
        if (dest[0] == "s16") {
            sampleFormat = OH_BitsPerSample::SAMPLE_S16LE;
        } else {
            sampleFormat = OH_BitsPerSample::SAMPLE_S32LE;
        }

        OH_AVFormat* format = getAVFormatFlac(channelCount, sampleRate, sampleFormat, bitrate);
        ASSERT_NE(nullptr, format);

        string inputFile = fileList[i];
        string outputFile = "FUNCTION_006_" + dest[0] + "_" + to_string(channelCount) + ".flac";

        encoderDemo->NativeRunCase(inputFile, outputFile, encoderName.c_str(), format);

        OH_AVFormat_Destroy(format);
    }
    delete encoderDemo;
}

/**
 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_FUNCTION_007
 * @tc.name      : Flush(AAC)
 * @tc.desc      : function check
 */
HWTEST_F(NativeFunctionTest, SUB_MULTIMEDIA_AUDIO_ENCODER_FUNCTION_007, TestSize.Level2)
{
    AudioEncoderDemo* encoderDemo = new AudioEncoderDemo();
    string decoderName = "OH.Media.Codec.Encoder.Audio.AAC";

    string inputFile = "f32le_16000_2_dayuhaitang.pcm";
    string firstOutputFile = "FUNCTION_007_1.aac";
    string secondOutputFile = "FUNCTION_007_2.aac";

    OH_AVFormat* format = OH_AVFormat_Create();
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 2);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 16000);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, OH_BitsPerSample::SAMPLE_F32LE);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, OH_BitsPerSample::SAMPLE_F32LE);
    OH_AVFormat_SetLongValue(format, OH_MD_KEY_CHANNEL_LAYOUT, STEREO);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_TYPE);
    OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, 129000);

    encoderDemo->NativeRunCaseFlush(inputFile, firstOutputFile, secondOutputFile, decoderName.c_str(), format);

    bool isSame = compareFile(firstOutputFile, secondOutputFile);
    ASSERT_EQ(true, isSame);

    OH_AVFormat_Destroy(format);
    delete encoderDemo;
}

/**
 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_FUNCTION_008
 * @tc.name      : Flush(flac)
 * @tc.desc      : function check
 */
HWTEST_F(NativeFunctionTest, SUB_MULTIMEDIA_AUDIO_ENCODER_FUNCTION_008, TestSize.Level2)
{
    AudioEncoderDemo* encoderDemo = new AudioEncoderDemo();
    string decoderName = "OH.Media.Codec.Encoder.Audio.Flac";

    string inputFile = "s16_48000_2_dayuhaitang.pcm";
    string firstOutputFile = "FUNCTION_008_1.flac";
    string secondOutputFile = "FUNCTION_008_2.flac";

    OH_AVFormat* format = OH_AVFormat_Create();
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 2);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 48000);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, OH_BitsPerSample::SAMPLE_S16LE);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, OH_BitsPerSample::SAMPLE_S16LE);
    OH_AVFormat_SetLongValue(format, OH_MD_KEY_CHANNEL_LAYOUT, STEREO);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_TYPE);
    OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, 129000);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_MAX_INPUT_SIZE,
        COMMON_FLAC_NUM * CHANNEL_COUNT_STEREO * S16_BITS_PER_SAMPLE);

    encoderDemo->NativeRunCaseFlush(inputFile, firstOutputFile, secondOutputFile, decoderName.c_str(), format);

    bool isSame = compareFile(firstOutputFile, secondOutputFile);
    ASSERT_EQ(true, isSame);

    OH_AVFormat_Destroy(format);
    delete encoderDemo;
}

/**
 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_FUNCTION_009
 * @tc.name      : Reset(AAC)
 * @tc.desc      : function check
 */
HWTEST_F(NativeFunctionTest, SUB_MULTIMEDIA_AUDIO_ENCODER_FUNCTION_009, TestSize.Level2)
{
    AudioEncoderDemo* encoderDemo = new AudioEncoderDemo();
    string decoderName = "OH.Media.Codec.Encoder.Audio.AAC";

    string inputFile = "f32le_16000_2_dayuhaitang.pcm";
    string firstOutputFile = "FUNCTION_009_1.aac";
    string secondOutputFile = "FUNCTION_009_2.aac";

    OH_AVFormat* format = OH_AVFormat_Create();
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 2);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 16000);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, OH_BitsPerSample::SAMPLE_F32LE);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, OH_BitsPerSample::SAMPLE_F32LE);
    OH_AVFormat_SetLongValue(format, OH_MD_KEY_CHANNEL_LAYOUT, STEREO);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_TYPE);
    OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, 129000);

    encoderDemo->NativeRunCaseReset(inputFile, firstOutputFile, secondOutputFile, decoderName.c_str(), format);

    bool isSame = compareFile(firstOutputFile, secondOutputFile);
    ASSERT_EQ(true, isSame);

    OH_AVFormat_Destroy(format);
    delete encoderDemo;
}

/**
 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_FUNCTION_010
 * @tc.name      : Reset(flac)
 * @tc.desc      : function check
 */
HWTEST_F(NativeFunctionTest, SUB_MULTIMEDIA_AUDIO_ENCODER_FUNCTION_010, TestSize.Level2)
{
    AudioEncoderDemo* encoderDemo = new AudioEncoderDemo();
    string decoderName = "OH.Media.Codec.Encoder.Audio.Flac";

    string inputFile = "s16_48000_2_dayuhaitang.pcm";
    string firstOutputFile = "FUNCTION_010_1.flac";
    string secondOutputFile = "FUNCTION_010_2.flac";

    OH_AVFormat* format = OH_AVFormat_Create();
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 2);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 48000);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, OH_BitsPerSample::SAMPLE_S16LE);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, OH_BitsPerSample::SAMPLE_S16LE);
    OH_AVFormat_SetLongValue(format, OH_MD_KEY_CHANNEL_LAYOUT, STEREO);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_TYPE);
    OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, 129000);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_MAX_INPUT_SIZE,
        COMMON_FLAC_NUM * CHANNEL_COUNT_STEREO * S16_BITS_PER_SAMPLE);

    encoderDemo->NativeRunCaseReset(inputFile, firstOutputFile, secondOutputFile, decoderName.c_str(), format);

    bool isSame = compareFile(firstOutputFile, secondOutputFile);
    ASSERT_EQ(true, isSame);

    OH_AVFormat_Destroy(format);
    delete encoderDemo;
}


/**
 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_FUNCTION_011
 * @tc.name      : OH_AudioEncoder_GetOutputDescription
 * @tc.desc      : function check
 */
HWTEST_F(NativeFunctionTest, SUB_MULTIMEDIA_AUDIO_ENCODER_FUNCTION_011, TestSize.Level2)
{
    AudioEncoderDemo* encoderDemo = new AudioEncoderDemo();
    string encoderName = "OH.Media.Codec.Encoder.Audio.AAC";

    string inputFile = "f32le_16000_2_dayuhaitang.pcm";
    string outputFile = "FUNCTION_011.aac";

    OH_AVFormat* format = OH_AVFormat_Create();
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 2);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 16000);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, OH_BitsPerSample::SAMPLE_F32LE);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, OH_BitsPerSample::SAMPLE_F32LE);
    OH_AVFormat_SetLongValue(format, OH_MD_KEY_CHANNEL_LAYOUT, STEREO);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_TYPE);
    OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, 129000);

    OH_AVFormat* formatGet = encoderDemo->NativeRunCaseGetOutputDescription(inputFile, outputFile, encoderName.c_str(),
        format);
    ASSERT_NE(nullptr, formatGet);

    int32_t channelNum_Get;
    int32_t sampleRate_Get;
    int64_t bitrate_Get;
    OH_AVFormat_GetIntValue(formatGet, OH_MD_KEY_AUD_CHANNEL_COUNT, &channelNum_Get);
    OH_AVFormat_GetIntValue(formatGet, OH_MD_KEY_AUD_SAMPLE_RATE, &sampleRate_Get);
    OH_AVFormat_GetLongValue(formatGet, OH_MD_KEY_BITRATE, &bitrate_Get);

    const char* testStr = nullptr;
    OH_AVFormat_GetStringValue(formatGet, OH_MD_KEY_CODEC_MIME, &testStr);

    cout << "channel num is " << channelNum_Get << ", sample rate is " <<
    sampleRate_Get << ", bitrate is " << bitrate_Get << endl;

    cout << "OH_MD_KEY_CODEC_MIME is " << testStr << endl;

    ASSERT_EQ(2, channelNum_Get);
    ASSERT_EQ(16000, sampleRate_Get);
    ASSERT_EQ(129000, bitrate_Get);

    OH_AVFormat_Destroy(format);
    OH_AVFormat_Destroy(formatGet);
    delete encoderDemo;
}

/**
 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_FUNCTION_012
 * @tc.name      : AAC(thread)
 * @tc.desc      : Function test
 */
HWTEST_F(NativeFunctionTest, SUB_MULTIMEDIA_AUDIO_ENCODER_FUNCTION_012, TestSize.Level2)
{
    vector<thread> threadVec;
    string encoderName = "OH.Media.Codec.Encoder.Audio.AAC";

    string inputFile = "f32le_16000_2_dayuhaitang.pcm";

    for (int32_t i = 0; i < 16; i++)
    {
        string outputFile = "FUNCTION_012_" + to_string(i) + ".aac";
        threadVec.push_back(thread(runEncode, encoderName, inputFile, outputFile, i));
    }
    for (uint32_t i = 0; i < threadVec.size(); i++)
    {
        threadVec[i].join();
    }
    for (int32_t i = 0; i < 16; i++)
    {
        ASSERT_EQ(AV_ERR_OK, testResult[i]);
    }
}

/**
 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_FUNCTION_013
 * @tc.name      : flac(thread)
 * @tc.desc      : Function test
 */
HWTEST_F(NativeFunctionTest, SUB_MULTIMEDIA_AUDIO_ENCODER_FUNCTION_013, TestSize.Level2)
{
    vector<thread> threadVec;
    string encoderName = "OH.Media.Codec.Encoder.Audio.Flac";

    string inputFile = "s16_48000_2_dayuhaitang.pcm";

    for (int32_t i = 0; i < 16; i++)
    {
        string outputFile = "FUNCTION_013_" + to_string(i) + ".flac";
        threadVec.push_back(thread(runEncode, encoderName, inputFile, outputFile, i));
    }
    for (uint32_t i = 0; i < threadVec.size(); i++)
    {
        threadVec[i].join();
    }
    for (int32_t i = 0; i < 16; i++)
    {
        ASSERT_EQ(AV_ERR_OK, testResult[i]);
    }
}

/**
 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_FUNCTION_100
 * @tc.name      : AAC
 * @tc.desc      : function check
 */
HWTEST_F(NativeFunctionTest, SUB_MULTIMEDIA_AUDIO_ENCODER_FUNCTION_100, TestSize.Level2)
{
    AudioEncoderDemo* encoderDemo = new AudioEncoderDemo();
    string encoderName = "OH.Media.Codec.Encoder.Audio.AAC";

    string inputFile = "B_Bird_on_a_wire_1_f32.pcm";
    string outputFile = "FUNCTION_100.aac";

    OH_AVFormat* format = OH_AVFormat_Create();
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 1);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 48000);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, OH_BitsPerSample::SAMPLE_F32LE);

    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, OH_BitsPerSample::SAMPLE_F32LE);
    OH_AVFormat_SetLongValue(format, OH_MD_KEY_CHANNEL_LAYOUT, MONO);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AAC_IS_ADTS, DEFAULT_AAC_TYPE);
    OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, 128000);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_MAX_INPUT_SIZE, 48000);
    ASSERT_NE(nullptr, format);

    encoderDemo->NativeRunCasePerformance(inputFile, outputFile, encoderName.c_str(), format);

    OH_AVFormat_Destroy(format);
    delete encoderDemo;
}

/**
 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_FUNCTION_200
 * @tc.name      : FLAC
 * @tc.desc      : function check
 */
HWTEST_F(NativeFunctionTest, SUB_MULTIMEDIA_AUDIO_ENCODER_FUNCTION_200, TestSize.Level2)
{
    AudioEncoderDemo* encoderDemo = new AudioEncoderDemo();
    string encoderName = "OH.Media.Codec.Encoder.Audio.Flac";

    string inputFile = "B_Bird_on_a_wire_1_1.pcm";
    string outputFile = "FUNCTION_200.flac";

    OH_AVFormat* format = OH_AVFormat_Create();
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 1);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 48000);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, OH_BitsPerSample::SAMPLE_S16LE);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, OH_BitsPerSample::SAMPLE_S16LE);
    OH_AVFormat_SetLongValue(format, OH_MD_KEY_CHANNEL_LAYOUT, MONO);
    OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, 429000);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_COMPLIANCE_LEVEL, -2);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_MAX_INPUT_SIZE, 48000);
    ASSERT_NE(nullptr, format);

    encoderDemo->NativeRunCasePerformance(inputFile, outputFile, encoderName.c_str(), format);

    OH_AVFormat_Destroy(format);
    delete encoderDemo;
}

/**
 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_FUNCTION_201
 * @tc.name      : FLAC
 * @tc.desc      : function check
 */
HWTEST_F(NativeFunctionTest, SUB_MULTIMEDIA_AUDIO_ENCODER_FUNCTION_201, TestSize.Level2)
{
    AudioEncoderDemo* encoderDemo = new AudioEncoderDemo();
    string encoderName = "OH.Media.Codec.Encoder.Audio.Flac";

    string inputFile = "free_loss.pcm";
    string outputFile = "FUNCTION_201.flac";

    OH_AVFormat* format = OH_AVFormat_Create();
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 1);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 48000);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, OH_BitsPerSample::SAMPLE_S16LE);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, OH_BitsPerSample::SAMPLE_S16LE);
    OH_AVFormat_SetLongValue(format, OH_MD_KEY_CHANNEL_LAYOUT, MONO);
    OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, 613000);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_COMPLIANCE_LEVEL, -2);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_MAX_INPUT_SIZE, 48000);
    ASSERT_NE(nullptr, format);

    encoderDemo->NativeRunCasePerformance(inputFile, outputFile, encoderName.c_str(), format);

    OH_AVFormat_Destroy(format);
    delete encoderDemo;
}

/**
 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_FUNCTION_202
 * @tc.name      : FLAC
 * @tc.desc      : function check
 */
HWTEST_F(NativeFunctionTest, SUB_MULTIMEDIA_AUDIO_ENCODER_FUNCTION_202, TestSize.Level2)
{
    AudioEncoderDemo* encoderDemo = new AudioEncoderDemo();
    string encoderName = "OH.Media.Codec.Encoder.Audio.Flac";

    string inputFile = "B_Bird_on_a_wire_1_1.pcm";
    string outputFile = "FUNCTION_202.dat";

    OH_AVFormat* format = OH_AVFormat_Create();
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 1);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 48000);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, OH_BitsPerSample::SAMPLE_S16LE);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, OH_BitsPerSample::SAMPLE_S16LE);
    OH_AVFormat_SetLongValue(format, OH_MD_KEY_CHANNEL_LAYOUT, MONO);
    OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, 429000);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_COMPLIANCE_LEVEL, -2);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_MAX_INPUT_SIZE, 48000);
    ASSERT_NE(nullptr, format);

    encoderDemo->TestRunCase(inputFile, outputFile, encoderName.c_str(), format);

    OH_AVFormat_Destroy(format);
    delete encoderDemo;
}

/**
 * @tc.number    : SUB_MULTIMEDIA_AUDIO_ENCODER_FUNCTION_203
 * @tc.name      : FLAC
 * @tc.desc      : function check
 */
HWTEST_F(NativeFunctionTest, SUB_MULTIMEDIA_AUDIO_ENCODER_FUNCTION_203, TestSize.Level2)
{
    AudioEncoderDemo* encoderDemo = new AudioEncoderDemo();
    string encoderName = "OH.Media.Codec.Encoder.Audio.Flac";

    string inputFile = "free_loss.pcm";
    string outputFile = "FUNCTION_203.dat";

    OH_AVFormat* format = OH_AVFormat_Create();
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_CHANNEL_COUNT, 1);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUD_SAMPLE_RATE, 96000);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_BITS_PER_CODED_SAMPLE, OH_BitsPerSample::SAMPLE_S16LE);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_AUDIO_SAMPLE_FORMAT, OH_BitsPerSample::SAMPLE_S16LE);
    OH_AVFormat_SetLongValue(format, OH_MD_KEY_CHANNEL_LAYOUT, MONO);
    OH_AVFormat_SetLongValue(format, OH_MD_KEY_BITRATE, 613000);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_COMPLIANCE_LEVEL, -2);
    OH_AVFormat_SetIntValue(format, OH_MD_KEY_MAX_INPUT_SIZE, 16384);
    ASSERT_NE(nullptr, format);

    encoderDemo->TestRunCase(inputFile, outputFile, encoderName.c_str(), format);

    OH_AVFormat_Destroy(format);
    delete encoderDemo;
}