1 /* 2 * Copyright (c) 2022 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include <benchmark/benchmark.h> 17 #include <string> 18 #include <vector> 19 #include <chrono> 20 #include <thread> 21 #include "audio_errors.h" 22 #include "audio_info.h" 23 #include "audio_renderer.h" 24 using namespace std; 25 using namespace OHOS; 26 using namespace OHOS::AudioStandard; 27 28 namespace { 29 class BenchmarkAudiorendererTest : public benchmark::Fixture { 30 public: BenchmarkAudiorendererTest()31 BenchmarkAudiorendererTest() 32 { 33 Iterations(iterations); 34 Repetitions(repetitions); 35 ReportAggregatesOnly(); 36 } 37 38 ~BenchmarkAudiorendererTest() override = default; 39 SetUp(const::benchmark::State & state)40 void SetUp(const ::benchmark::State &state) override 41 { 42 sleep(1); 43 AudioRendererOptions rendererOptions; 44 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100; 45 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM; 46 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE; 47 rendererOptions.streamInfo.channels = AudioChannel::STEREO; 48 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC; 49 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA; 50 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG; 51 audioRenderer = AudioRenderer::Create(rendererOptions); 52 sleep(1); 53 } 54 TearDown(const::benchmark::State & state)55 void TearDown(const ::benchmark::State &state) override 56 { 57 audioRenderer->Release(); 58 } 59 60 protected: 61 unique_ptr<AudioRenderer> audioRenderer; 62 const int32_t RENDERER_FLAG = 0; 63 const int32_t repetitions = 3; 64 const int32_t iterations = 300; 65 const string AUDIORENDER_TEST_FILE_PATH = "/data/test_44100_2.wav"; 66 }; 67 68 // StartAbility BENCHMARK_F(BenchmarkAudiorendererTest,StartAbilityTestCase)69 BENCHMARK_F(BenchmarkAudiorendererTest, StartAbilityTestCase) 70 ( 71 benchmark::State &state) 72 { 73 while (state.KeepRunning()) 74 { 75 bool isStarted = audioRenderer->Start(); 76 if (isStarted == false) 77 { 78 state.SkipWithError("StartAbilityTestCase audioRenderer start failed."); 79 } 80 81 state.PauseTiming(); 82 bool isStopped = audioRenderer->Stop(); 83 if (isStopped == false) 84 { 85 state.SkipWithError("StartAbilityTestCase audioRenderer start failed."); 86 } 87 state.ResumeTiming(); 88 } 89 } 90 91 // PauseAbility BENCHMARK_F(BenchmarkAudiorendererTest,PauseAbilityTestCase)92 BENCHMARK_F(BenchmarkAudiorendererTest, PauseAbilityTestCase) 93 ( 94 benchmark::State &state) 95 { 96 while (state.KeepRunning()) 97 { 98 state.PauseTiming(); 99 bool isStarted = audioRenderer->Start(); 100 if (isStarted == false) 101 { 102 state.SkipWithError("PauseAbilityTestCase audioRenderer start failed."); 103 } 104 105 bool isPaused = audioRenderer->Pause(); 106 if (isPaused == false) 107 { 108 state.SkipWithError("PauseAbilityTestCase audioRenderer pause failed."); 109 } 110 111 state.PauseTiming(); 112 bool isStopped = audioRenderer->Stop(); 113 if (isStopped == false) 114 { 115 state.SkipWithError("PauseAbilityTestCase audioRenderer start failed."); 116 } 117 state.ResumeTiming(); 118 } 119 } 120 121 // StopAbility BENCHMARK_F(BenchmarkAudiorendererTest,StopAbilityTestCase)122 BENCHMARK_F(BenchmarkAudiorendererTest, StopAbilityTestCase) 123 ( 124 benchmark::State &state) 125 { 126 while (state.KeepRunning()) 127 { 128 state.PauseTiming(); 129 bool isStarted = audioRenderer->Start(); 130 if (isStarted == false) 131 { 132 state.SkipWithError("StopAbilityTestCase audioRenderer start failed."); 133 } 134 state.ResumeTiming(); 135 136 bool isStopped = audioRenderer->Stop(); 137 if (isStopped == false) 138 { 139 state.SkipWithError("StopAbilityTestCase audioRenderer start failed."); 140 } 141 } 142 } 143 144 // SetVolumeAbility BENCHMARK_F(BenchmarkAudiorendererTest,SetVolumeAbilityTestCase)145 BENCHMARK_F(BenchmarkAudiorendererTest, SetVolumeAbilityTestCase) 146 ( 147 benchmark::State &state) 148 { 149 while (state.KeepRunning()) 150 { 151 state.PauseTiming(); 152 int32_t ret = -1; 153 ret = audioRenderer->SetVolume(0); 154 if (ret != SUCCESS) 155 { 156 state.SkipWithError("SetVolumeAbilityTestCase 0 audioRenderer failed."); 157 } 158 state.ResumeTiming(); 159 160 ret = audioRenderer->SetVolume(1.0); 161 if (ret != SUCCESS) 162 { 163 state.SkipWithError("SetVolumeAbilityTestCase 1.0 audioRenderer failed."); 164 } 165 } 166 } 167 168 // WriteAbility ****************** write BENCHMARK_F(BenchmarkAudiorendererTest,WriteAbilityTestCase)169 BENCHMARK_F(BenchmarkAudiorendererTest, WriteAbilityTestCase) 170 ( 171 benchmark::State &state) 172 { 173 while (state.KeepRunning()) 174 { 175 state.PauseTiming(); 176 int32_t ret = -1; 177 178 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb"); 179 if (wavFile == nullptr) 180 { 181 state.SkipWithError("WriteAbilityTestCase fopen fail"); 182 } 183 184 bool isStarted = audioRenderer->Start(); 185 if (isStarted == false) 186 { 187 state.SkipWithError("WriteAbilityTestCase audioRenderer start fail"); 188 } 189 190 size_t bufferLen; 191 ret = audioRenderer->GetBufferSize(bufferLen); 192 193 uint8_t *buffer = (uint8_t *)malloc(bufferLen); 194 if (buffer == nullptr) 195 { 196 state.SkipWithError("WriteAbilityTestCase getbuffer fail"); 197 } 198 size_t bytesToWrite = 0; 199 int32_t bytesWritten = 0; 200 201 bytesToWrite = fread(buffer, 1, bufferLen, wavFile); 202 state.ResumeTiming(); 203 204 bytesWritten = audioRenderer->Write(buffer, bytesToWrite); 205 if (bytesWritten <= 0) 206 { 207 state.SkipWithError("WriteAbilityTestCase Write fail"); 208 } 209 state.PauseTiming(); 210 audioRenderer->Stop(); 211 free(buffer); 212 fclose(wavFile); 213 state.ResumeTiming(); 214 } 215 } 216 } 217 218 // Run the benchmark 219 BENCHMARK_MAIN();