| /* |
| * 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. |
| */ |
| |
| //#define LOG_NDEBUG 0 |
| #define LOG_TAG "SonivoxTest" |
| #include <utils/Log.h> |
| |
| #include <fcntl.h> |
| #include <unistd.h> |
| #include <fstream> |
| |
| #include <libsonivox/eas.h> |
| #include <libsonivox/eas_reverb.h> |
| |
| #include "SonivoxTestEnvironment.h" |
| |
| #define OUTPUT_FILE "/data/local/tmp/output_midi.pcm" |
| |
| // number of Sonivox output buffers to aggregate into one MediaBuffer |
| static constexpr uint32_t kNumBuffersToCombine = 4; |
| static constexpr uint32_t kSeekBeyondPlayTimeOffsetMs = 10; |
| |
| static SonivoxTestEnvironment *gEnv = nullptr; |
| static int readAt(void *, void *, int, int); |
| static int getSize(void *); |
| |
| class SonivoxTest : public ::testing::TestWithParam<tuple</*fileName*/ string, |
| /*audioPlayTimeMs*/ uint32_t, |
| /*totalChannels*/ uint32_t, |
| /*sampleRateHz*/ uint32_t>> { |
| public: |
| SonivoxTest() |
| : mFd(-1), |
| mInputFp(nullptr), |
| mEASDataHandle(nullptr), |
| mEASStreamHandle(nullptr), |
| mPCMBuffer(nullptr), |
| mAudioBuffer(nullptr), |
| mEASConfig(nullptr) {} |
| |
| ~SonivoxTest() { |
| if (mInputFp) fclose(mInputFp); |
| if (mFd >= 0) close(mFd); |
| if (mPCMBuffer) { |
| delete[] mPCMBuffer; |
| mPCMBuffer = nullptr; |
| } |
| if (mAudioBuffer) { |
| delete[] mAudioBuffer; |
| mAudioBuffer = nullptr; |
| } |
| if (gEnv->cleanUp()) remove(OUTPUT_FILE); |
| } |
| |
| virtual void SetUp() override { |
| tuple<string, uint32_t, uint32_t, uint32_t> params = GetParam(); |
| mInputMediaFile = gEnv->getRes() + get<0>(params); |
| mAudioplayTimeMs = get<1>(params); |
| mTotalAudioChannels = get<2>(params); |
| mAudioSampleRate = get<3>(params); |
| |
| mFd = open(mInputMediaFile.c_str(), O_RDONLY | O_LARGEFILE); |
| ASSERT_GE(mFd, 0) << "Failed to get the file descriptor for file: " << mInputMediaFile; |
| |
| struct stat buf; |
| int8_t err = stat(mInputMediaFile.c_str(), &buf); |
| ASSERT_EQ(err, 0) << "Failed to get information for file: " << mInputMediaFile; |
| |
| mBase = 0; |
| mLength = buf.st_size; |
| mEasFile.handle = this; |
| mEasFile.readAt = ::readAt; |
| mEasFile.size = ::getSize; |
| |
| EAS_RESULT result = EAS_Init(&mEASDataHandle); |
| ASSERT_EQ(result, EAS_SUCCESS) << "Failed to initialize synthesizer library"; |
| |
| ASSERT_NE(mEASDataHandle, nullptr) << "Failed to initialize EAS data handle"; |
| |
| result = EAS_OpenFile(mEASDataHandle, &mEasFile, &mEASStreamHandle); |
| ASSERT_EQ(result, EAS_SUCCESS) << "Failed to open file"; |
| |
| ASSERT_NE(mEASStreamHandle, nullptr) << "Failed to initialize EAS stream handle"; |
| |
| result = EAS_Prepare(mEASDataHandle, mEASStreamHandle); |
| ASSERT_EQ(result, EAS_SUCCESS) << "Failed to prepare EAS data and stream handles"; |
| |
| EAS_I32 playTimeMs; |
| result = EAS_ParseMetaData(mEASDataHandle, mEASStreamHandle, &playTimeMs); |
| ASSERT_EQ(result, EAS_SUCCESS) << "Failed to parse meta data"; |
| |
| ASSERT_EQ(playTimeMs, mAudioplayTimeMs) |
| << "Invalid audio play time found for file: " << mInputMediaFile; |
| |
| EAS_I32 locationMs = -1; |
| /* EAS_ParseMetaData resets the parser to the starting of file */ |
| result = EAS_GetLocation(mEASDataHandle, mEASStreamHandle, &locationMs); |
| ASSERT_EQ(result, EAS_SUCCESS) << "Failed to get the location after parsing meta data"; |
| |
| ASSERT_EQ(locationMs, 0) << "Expected position: 0, found: " << locationMs; |
| |
| mEASConfig = EAS_Config(); |
| ASSERT_NE(mEASConfig, nullptr) << "Failed to configure the library"; |
| |
| ASSERT_GT(mEASConfig->mixBufferSize, 0) << "Mix buffer size must be greater than 0"; |
| |
| ASSERT_GT(mEASConfig->numChannels, 0) << "Number of channels must be greater than 0"; |
| |
| mPCMBufferSize = sizeof(EAS_PCM) * mEASConfig->mixBufferSize * mEASConfig->numChannels * |
| kNumBuffersToCombine; |
| |
| mPCMBuffer = new (std::nothrow) EAS_PCM[mPCMBufferSize]; |
| ASSERT_NE(mPCMBuffer, nullptr) << "Failed to allocate a memory of size: " << mPCMBufferSize; |
| |
| mAudioBuffer = |
| new (std::nothrow) EAS_PCM[mEASConfig->mixBufferSize * mEASConfig->numChannels]; |
| ASSERT_NE(mAudioBuffer, nullptr) << "Failed to allocate a memory of size: " |
| << mEASConfig->mixBufferSize * mEASConfig->numChannels; |
| } |
| |
| virtual void TearDown() { |
| EAS_RESULT result; |
| if (mEASDataHandle) { |
| if (mEASStreamHandle) { |
| result = EAS_CloseFile(mEASDataHandle, mEASStreamHandle); |
| ASSERT_EQ(result, EAS_SUCCESS) << "Failed to close audio file/stream"; |
| } |
| result = EAS_Shutdown(mEASDataHandle); |
| ASSERT_EQ(result, EAS_SUCCESS) |
| << "Failed to deallocate the resources for synthesizer library"; |
| } |
| } |
| |
| bool seekToLocation(EAS_I32); |
| bool renderAudio(); |
| int readAt(void *buf, int offset, int size); |
| int getSize(); |
| |
| string mInputMediaFile; |
| uint32_t mAudioplayTimeMs; |
| uint32_t mTotalAudioChannels; |
| uint32_t mAudioSampleRate; |
| off64_t mBase; |
| int64_t mLength; |
| int mFd; |
| |
| FILE *mInputFp; |
| EAS_DATA_HANDLE mEASDataHandle; |
| EAS_HANDLE mEASStreamHandle; |
| EAS_FILE mEasFile; |
| EAS_PCM *mPCMBuffer; |
| EAS_PCM *mAudioBuffer; |
| EAS_I32 mPCMBufferSize; |
| const S_EAS_LIB_CONFIG *mEASConfig; |
| }; |
| |
| static int readAt(void *handle, void *buffer, int offset, int size) { |
| return ((SonivoxTest *)handle)->readAt(buffer, offset, size); |
| } |
| |
| static int getSize(void *handle) { |
| return ((SonivoxTest *)handle)->getSize(); |
| } |
| |
| int SonivoxTest::readAt(void *buffer, int offset, int size) { |
| if (offset > mLength) offset = mLength; |
| lseek(mFd, mBase + offset, SEEK_SET); |
| if (offset + size > mLength) { |
| size = mLength - offset; |
| } |
| |
| return read(mFd, buffer, size); |
| } |
| |
| int SonivoxTest::getSize() { |
| return mLength; |
| } |
| |
| bool SonivoxTest::seekToLocation(EAS_I32 locationExpectedMs) { |
| EAS_RESULT result = EAS_Locate(mEASDataHandle, mEASStreamHandle, locationExpectedMs, false); |
| if (result != EAS_SUCCESS) return false; |
| |
| // position in milliseconds |
| EAS_I32 locationReceivedMs; |
| result = EAS_GetLocation(mEASDataHandle, mEASStreamHandle, &locationReceivedMs); |
| if (result != EAS_SUCCESS) return false; |
| |
| if (locationReceivedMs != locationExpectedMs) return false; |
| |
| return true; |
| } |
| |
| bool SonivoxTest::renderAudio() { |
| EAS_I32 count = -1; |
| EAS_PCM *pcm = mAudioBuffer; |
| |
| EAS_RESULT result = EAS_Render(mEASDataHandle, pcm, mEASConfig->mixBufferSize, &count); |
| if (result != EAS_SUCCESS) { |
| ALOGE("Failed to render audio"); |
| return false; |
| } |
| if (count != mEASConfig->mixBufferSize) { |
| ALOGE("%ld of %ld bytes rendered", count, mEASConfig->mixBufferSize); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| TEST_P(SonivoxTest, DecodeTest) { |
| EAS_I32 totalChannels = mEASConfig->numChannels; |
| ASSERT_EQ(totalChannels, mTotalAudioChannels) |
| << "Expected: " << mTotalAudioChannels << " channels, Found: " << totalChannels; |
| |
| EAS_I32 sampleRate = mEASConfig->sampleRate; |
| ASSERT_EQ(sampleRate, mAudioSampleRate) |
| << "Expected: " << mAudioSampleRate << " sample rate, Found: " << sampleRate; |
| |
| // TODO(b/158231824): Check and verify the output with other parameters present at eas_reverb.h |
| // select reverb preset and enable |
| EAS_RESULT result = EAS_SetParameter(mEASDataHandle, EAS_MODULE_REVERB, EAS_PARAM_REVERB_PRESET, |
| EAS_PARAM_REVERB_CHAMBER); |
| ASSERT_EQ(result, EAS_SUCCESS) |
| << "Failed to set reverberation preset parameter in reverb module"; |
| |
| result = |
| EAS_SetParameter(mEASDataHandle, EAS_MODULE_REVERB, EAS_PARAM_REVERB_BYPASS, EAS_FALSE); |
| ASSERT_EQ(result, EAS_SUCCESS) |
| << "Failed to set reverberation bypass parameter in reverb module"; |
| |
| EAS_I32 count; |
| EAS_STATE state; |
| |
| FILE *filePtr = fopen(OUTPUT_FILE, "wb"); |
| ASSERT_NE(filePtr, nullptr) << "Failed to open file: " << OUTPUT_FILE; |
| |
| while (1) { |
| EAS_PCM *pcm = mPCMBuffer; |
| int32_t numBytesOutput = 0; |
| result = EAS_State(mEASDataHandle, mEASStreamHandle, &state); |
| ASSERT_EQ(result, EAS_SUCCESS) << "Failed to get EAS State"; |
| |
| ASSERT_NE(state, EAS_STATE_ERROR) << "Error state found"; |
| |
| /* is playback complete */ |
| if (state == EAS_STATE_STOPPED) { |
| break; |
| } |
| |
| EAS_I32 locationMs; |
| result = EAS_GetLocation(mEASDataHandle, mEASStreamHandle, &locationMs); |
| ASSERT_EQ(result, EAS_SUCCESS) << "Failed to get the current location in ms"; |
| |
| if (locationMs >= mAudioplayTimeMs) { |
| ASSERT_NE(state, EAS_STATE_STOPPED) |
| << "Invalid state reached when rendering is complete"; |
| |
| break; |
| } |
| |
| for (uint32_t i = 0; i < kNumBuffersToCombine; i++) { |
| result = EAS_Render(mEASDataHandle, pcm, mEASConfig->mixBufferSize, &count); |
| ASSERT_EQ(result, EAS_SUCCESS) << "Failed to render the audio data"; |
| |
| pcm += count * mEASConfig->numChannels; |
| numBytesOutput += count * mEASConfig->numChannels * sizeof(EAS_PCM); |
| } |
| int32_t numBytes = fwrite(mPCMBuffer, 1, numBytesOutput, filePtr); |
| ASSERT_EQ(numBytes, numBytesOutput) |
| << "Wrote " << numBytes << " of " << numBytesOutput << " to file: " << OUTPUT_FILE; |
| } |
| fclose(filePtr); |
| } |
| |
| TEST_P(SonivoxTest, SeekTest) { |
| bool status = seekToLocation(0); |
| ASSERT_TRUE(status) << "Seek test failed for location(ms): 0"; |
| |
| status = seekToLocation(mAudioplayTimeMs / 2); |
| ASSERT_TRUE(status) << "Seek test failed for location(ms): " << mAudioplayTimeMs / 2; |
| |
| status = seekToLocation(mAudioplayTimeMs); |
| ASSERT_TRUE(status) << "Seek test failed for location(ms): " << mAudioplayTimeMs; |
| |
| status = seekToLocation(mAudioplayTimeMs + kSeekBeyondPlayTimeOffsetMs); |
| ASSERT_FALSE(status) << "Invalid seek position: " |
| << mAudioplayTimeMs + kSeekBeyondPlayTimeOffsetMs; |
| } |
| |
| TEST_P(SonivoxTest, DecodePauseResumeTest) { |
| EAS_I32 seekPosition = mAudioplayTimeMs / 2; |
| // go to middle of the audio |
| EAS_RESULT result = EAS_Locate(mEASDataHandle, mEASStreamHandle, seekPosition, false); |
| ASSERT_EQ(result, EAS_SUCCESS) << "Failed to locate to location(ms): " << seekPosition; |
| |
| bool status = renderAudio(); |
| ASSERT_TRUE(status) << "Failed to render audio"; |
| |
| result = EAS_Pause(mEASDataHandle, mEASStreamHandle); |
| ASSERT_EQ(result, EAS_SUCCESS) << "Failed to pause"; |
| |
| // will render previous audio again, no change in audio position |
| status = renderAudio(); |
| ASSERT_TRUE(status) << "should not move audio position, since we're paused"; |
| |
| // current position in milliseconds |
| EAS_I32 currentPosMs = -1; |
| result = EAS_GetLocation(mEASDataHandle, mEASStreamHandle, ¤tPosMs); |
| ASSERT_EQ(result, EAS_SUCCESS) << "Failed to get current location"; |
| |
| ASSERT_EQ(currentPosMs, seekPosition) << "Must not move the audio position after pause"; |
| |
| EAS_STATE state; |
| result = EAS_State(mEASDataHandle, mEASStreamHandle, &state); |
| ASSERT_EQ(result, EAS_SUCCESS) << "Failed to get EAS state"; |
| |
| ASSERT_EQ(state, EAS_STATE_PAUSED) << "Invalid state reached when paused"; |
| |
| result = EAS_Resume(mEASDataHandle, mEASStreamHandle); |
| ASSERT_EQ(result, EAS_SUCCESS) << "Failed to resume"; |
| |
| status = renderAudio(); |
| ASSERT_TRUE(status) << "Failed to render audio after resume"; |
| |
| currentPosMs = -1; |
| result = EAS_GetLocation(mEASDataHandle, mEASStreamHandle, ¤tPosMs); |
| ASSERT_EQ(result, EAS_SUCCESS) << "Failed to get current location"; |
| |
| ASSERT_GT(currentPosMs, seekPosition) << "Invalid position after resuming"; |
| |
| result = EAS_State(mEASDataHandle, mEASStreamHandle, &state); |
| ASSERT_EQ(result, EAS_SUCCESS) << "Failed to get EAS state"; |
| |
| ASSERT_EQ(state, EAS_STATE_PLAY) << "Invalid state reached when resumed"; |
| } |
| |
| INSTANTIATE_TEST_SUITE_P(SonivoxTestAll, SonivoxTest, |
| ::testing::Values(make_tuple("midi_a.mid", 2000, 2, 22050), |
| make_tuple("midi8sec.mid", 8002, 2, 22050), |
| make_tuple("midi_cs.mid", 2000, 2, 22050), |
| make_tuple("midi_gs.mid", 2000, 2, 22050), |
| make_tuple("ants.mid", 17233, 2, 22050), |
| make_tuple("testmxmf.mxmf", 29095, 2, 22050))); |
| |
| int main(int argc, char **argv) { |
| gEnv = new SonivoxTestEnvironment(); |
| ::testing::AddGlobalTestEnvironment(gEnv); |
| ::testing::InitGoogleTest(&argc, argv); |
| int status = gEnv->initFromOptions(argc, argv); |
| if (status == 0) { |
| status = RUN_ALL_TESTS(); |
| ALOGV("Test result = %d\n", status); |
| } |
| return status; |
| } |