audio_utils/PowerLog.cpp

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