1 /*
2  * Copyright 2017 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 // #define LOG_NDEBUG 0
18 #define LOG_TAG "audio_utils_PowerLog"
19 #include <log/log.h>
20 
21 #include <algorithm>
22 #include <iomanip>
23 #include <math.h>
24 #include <sstream>
25 #include <stdint.h>
26 
27 #include <audio_utils/clock.h>
28 #include <audio_utils/power.h>
29 #include <audio_utils/PowerLog.h>
30 
31 namespace android {
32 
33 // TODO move to separate file
34 template <typename T, size_t N>
array_size(const T (&)[N])35 constexpr size_t array_size(const T(&)[N])
36 {
37     return N;
38 }
39 
PowerLog(uint32_t sampleRate,uint32_t channelCount,audio_format_t format,size_t entries,size_t framesPerEntry)40 PowerLog::PowerLog(uint32_t sampleRate,
41         uint32_t channelCount,
42         audio_format_t format,
43         size_t entries,
44         size_t framesPerEntry)
45     : mCurrentTime(0)
46     , mCurrentEnergy(0)
47     , mCurrentFrames(0)
48     , mIdx(0)
49     , mConsecutiveZeroes(0)
50     , mSampleRate(sampleRate)
51     , mChannelCount(channelCount)
52     , mFormat(format)
53     , mFramesPerEntry(framesPerEntry)
54     , mEntries(entries)
55 {
56     (void)mSampleRate; // currently unused, for future use
57     LOG_ALWAYS_FATAL_IF(!audio_utils_is_compute_power_format_supported(format),
58             "unsupported format: %#x", format);
59 }
60 
log(const void * buffer,size_t frames,int64_t nowNs)61 void PowerLog::log(const void *buffer, size_t frames, int64_t nowNs)
62 {
63     std::lock_guard<std::mutex> guard(mLock);
64 
65     const size_t bytes_per_sample = audio_bytes_per_sample(mFormat);
66     while (frames > 0) {
67         // check partial computation
68         size_t required = mFramesPerEntry - mCurrentFrames;
69         size_t process = std::min(required, frames);
70 
71         if (mCurrentTime == 0) {
72             mCurrentTime = nowNs;
73         }
74         mCurrentEnergy +=
75                 audio_utils_compute_energy_mono(buffer, mFormat, process * mChannelCount);
76         mCurrentFrames += process;
77 
78         ALOGV("nowNs:%lld, required:%zu, process:%zu, mCurrentEnergy:%f, mCurrentFrames:%zu",
79                 (long long)nowNs, required, process, mCurrentEnergy, mCurrentFrames);
80         if (process < required) {
81             return;
82         }
83 
84         // We store the data as normalized energy per sample. The energy sequence is
85         // zero terminated. Consecutive zeroes are ignored.
86         if (mCurrentEnergy == 0.f) {
87             if (mConsecutiveZeroes++ == 0) {
88                 mEntries[mIdx++] = std::make_pair(nowNs, 0.f);
89                 // zero terminate the signal sequence.
90             }
91         } else {
92             mConsecutiveZeroes = 0;
93             mEntries[mIdx++] = std::make_pair(mCurrentTime, mCurrentEnergy);
94             ALOGV("writing %lld %f", (long long)mCurrentTime, mCurrentEnergy);
95         }
96         if (mIdx >= mEntries.size()) {
97             mIdx -= mEntries.size();
98         }
99         mCurrentTime = 0;
100         mCurrentEnergy = 0;
101         mCurrentFrames = 0;
102         frames -= process;
103         buffer = (const uint8_t *)buffer + mCurrentFrames * mChannelCount * bytes_per_sample;
104     }
105 }
106 
dumpToString(const char * prefix,size_t lines,int64_t limitNs) const107 std::string PowerLog::dumpToString(const char *prefix, size_t lines, int64_t limitNs) const
108 {
109     std::lock_guard<std::mutex> guard(mLock);
110 
111     const size_t maxColumns = 10;
112     const size_t numberOfEntries = mEntries.size();
113     if (lines == 0) lines = SIZE_MAX;
114 
115     // compute where to start logging
116     enum {
117         AT_END,
118         IN_SIGNAL,
119     } state = IN_SIGNAL;
120     size_t count = 1;
121     size_t column = 0;
122     size_t nonzeros = 0;
123     ssize_t offset; // TODO doesn't dump if # entries exceeds SSIZE_MAX
124     for (offset = 0; offset < (ssize_t)numberOfEntries && count < lines; ++offset) {
125         const size_t idx = (mIdx + numberOfEntries - offset - 1) % numberOfEntries; // reverse direction
126         const int64_t time = mEntries[idx].first;
127         const float energy = mEntries[idx].second;
128 
129         if (state == AT_END) {
130             if (energy == 0.f) {
131                 ALOGV("two zeroes detected");
132                 break; // normally single zero terminated - two zeroes means no more data.
133             }
134             state = IN_SIGNAL;
135         } else { // IN_SIGNAL
136             if (energy == 0.f) {
137                 if (column != 0) {
138                     column = 0;
139                     ++count;
140                 }
141                 state = AT_END;
142                 continue;
143             }
144         }
145         if (column == 0 && time < limitNs) {
146             break;
147         }
148         ++nonzeros;
149         if (++column == maxColumns) {
150             column = 0;
151             // TODO ideally we would peek the previous entry to see if it is 0
152             // to ensure we properly put in a starting signal bracket.
153             // We don't do that because it would complicate the logic here.
154             ++count;
155         }
156     }
157     if (offset > 0) {
158         --offset;
159     }
160     // We accumulate the log info into a string, and write to the fd once.
161     std::stringstream ss;
162     ss << std::fixed << std::setprecision(1);
163     // ss << std::scientific;
164     if (nonzeros == 0) {
165         ss << prefix << "Signal power history: (none)\n";
166     } else {
167         ss << prefix << "Signal power history:\n";
168 
169         size_t column = 0;
170         bool first = true;
171         bool start = false;
172         float cumulative = 0.f;
173         for (; offset >= 0; --offset) {
174             const size_t idx = (mIdx + numberOfEntries - offset - 1) % numberOfEntries;
175             const int64_t time = mEntries[idx].first;
176             const float energy = mEntries[idx].second;
177 
178             if (energy == 0.f) {
179                 if (!first) {
180                     ss << " ] sum(" << audio_utils_power_from_energy(cumulative) << ")";
181                 }
182                 cumulative = 0.f;
183                 column = 0;
184                 start = true;
185                 continue;
186             }
187             if (column == 0) {
188                 // print time if at start of column
189                 if (!first) {
190                     ss << "\n";
191                 }
192                 ss << prefix << " " << audio_utils_time_string_from_ns(time).time
193                         << (start ? ": [ ": ":   ");
194                 first = false;
195                 start = false;
196             }  else {
197                 ss << " ";
198             }
199             if (++column >= maxColumns) {
200                 column = 0;
201             }
202 
203             cumulative += energy;
204             // convert energy to power and print
205             const float power =
206                     audio_utils_power_from_energy(energy / (mChannelCount * mFramesPerEntry));
207             ss << std::setw(6) << power;
208             ALOGV("state: %d %lld %f", state, (long long)time, power);
209         }
210         ss << "\n";
211     }
212     return ss.str();
213 }
214 
dump(int fd,const char * prefix,size_t lines,int64_t limitNs) const215 status_t PowerLog::dump(int fd, const char *prefix, size_t lines, int64_t limitNs) const
216 {
217     // Since dumpToString and write are thread safe, this function
218     // is conceptually thread-safe but simultaneous calls to dump
219     // by different threads to the same file descriptor may not write
220     // the two logs in time order.
221     const std::string s = dumpToString(prefix, lines, limitNs);
222     if (s.size() > 0 && write(fd, s.c_str(), s.size()) < 0) {
223         return -errno;
224     }
225     return NO_ERROR;
226 }
227 
228 } // namespace android
229 
230 using namespace android;
231 
power_log_create(uint32_t sample_rate,uint32_t channel_count,audio_format_t format,size_t entries,size_t frames_per_entry)232 power_log_t *power_log_create(uint32_t sample_rate,
233         uint32_t channel_count, audio_format_t format, size_t entries, size_t frames_per_entry)
234 {
235     if (!audio_utils_is_compute_power_format_supported(format)) {
236         return nullptr;
237     }
238     return reinterpret_cast<power_log_t *>
239             (new(std::nothrow)
240                     PowerLog(sample_rate, channel_count, format, entries, frames_per_entry));
241 }
242 
power_log_log(power_log_t * power_log,const void * buffer,size_t frames,int64_t now_ns)243 void power_log_log(power_log_t *power_log,
244         const void *buffer, size_t frames, int64_t now_ns)
245 {
246     if (power_log == nullptr) {
247         return;
248     }
249     reinterpret_cast<PowerLog *>(power_log)->log(buffer, frames, now_ns);
250 }
251 
power_log_dump(power_log_t * power_log,int fd,const char * prefix,size_t lines,int64_t limit_ns)252 int power_log_dump(
253         power_log_t *power_log, int fd, const char *prefix, size_t lines, int64_t limit_ns)
254 {
255     if (power_log == nullptr) {
256         return BAD_VALUE;
257     }
258     return reinterpret_cast<PowerLog *>(power_log)->dump(fd, prefix, lines, limit_ns);
259 }
260 
power_log_destroy(power_log_t * power_log)261 void power_log_destroy(power_log_t *power_log)
262 {
263     delete reinterpret_cast<PowerLog *>(power_log);
264 }
265