audio_utils/PowerLog.cpp - platform/system/media - Gitiles

 /*
  * Copyright 2017 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 "audio_utils_PowerLog"
 #include <log/log.h>

 #include <algorithm>
 #include <iomanip>
 #include <math.h>
 #include <sstream>
 #include <stdint.h>
 #include <unistd.h>
 #include <vector>

 #include <audio_utils/clock.h>
 #include <audio_utils/LogPlot.h>
 #include <audio_utils/power.h>
 #include <audio_utils/PowerLog.h>

 namespace android {

 // TODO move to separate file
 template <typename T, size_t N>
 constexpr size_t array_size(const T(&)[N])
 {
     return N;
 }

 PowerLog::PowerLog(uint32_t sampleRate,
         uint32_t channelCount,
         audio_format_t format,
         size_t entries,
         size_t framesPerEntry)
     : mCurrentTime(0)
     , mCurrentEnergy(0)
     , mCurrentFrames(0)
     , mIdx(0)
     , mConsecutiveZeroes(0)
     , mSampleRate(sampleRate)
     , mChannelCount(channelCount)
     , mFormat(format)
     , mFramesPerEntry(framesPerEntry)
     , mEntries(entries)
 {
     (void)mSampleRate; // currently unused, for future use
     LOG_ALWAYS_FATAL_IF(!audio_utils_is_compute_power_format_supported(format),
             "unsupported format: %#x", format);
 }

 void PowerLog::log(const void *buffer, size_t frames, int64_t nowNs)
 {
     std::lock_guard<std::mutex> guard(mLock);

     const size_t bytes_per_sample = audio_bytes_per_sample(mFormat);
     while (frames > 0) {
         // check partial computation
         size_t required = mFramesPerEntry - mCurrentFrames;
         size_t process = std::min(required, frames);

         if (mCurrentTime == 0) {
             mCurrentTime = nowNs;
         }
         mCurrentEnergy +=
                 audio_utils_compute_energy_mono(buffer, mFormat, process * mChannelCount);
         mCurrentFrames += process;

         ALOGV("nowNs:%lld, required:%zu, process:%zu, mCurrentEnergy:%f, mCurrentFrames:%zu",
                 (long long)nowNs, required, process, mCurrentEnergy, mCurrentFrames);
         if (process < required) {
             return;
         }

         // We store the data as normalized energy per sample. The energy sequence is
         // zero terminated. Consecutive zeroes are ignored.
         if (mCurrentEnergy == 0.f) {
             if (mConsecutiveZeroes++ == 0) {
                 mEntries[mIdx++] = std::make_pair(nowNs, 0.f);
                 // zero terminate the signal sequence.
             }
         } else {
             mConsecutiveZeroes = 0;
             mEntries[mIdx++] = std::make_pair(mCurrentTime, mCurrentEnergy);
             ALOGV("writing %lld %f", (long long)mCurrentTime, mCurrentEnergy);
         }
         if (mIdx >= mEntries.size()) {
             mIdx -= mEntries.size();
         }
         mCurrentTime = 0;
         mCurrentEnergy = 0;
         mCurrentFrames = 0;
         frames -= process;
         buffer = (const uint8_t *)buffer + mCurrentFrames * mChannelCount * bytes_per_sample;
     }
 }

 std::string PowerLog::dumpToString(const char *prefix, size_t lines, int64_t limitNs) const
 {
     std::lock_guard<std::mutex> guard(mLock);

     const size_t maxColumns = 10;
     const size_t numberOfEntries = mEntries.size();
     if (lines == 0) lines = SIZE_MAX;

     // compute where to start logging
     enum {
         AT_END,
         IN_SIGNAL,
     } state = IN_SIGNAL;
     size_t count = 1;
     size_t column = 0;
     size_t nonzeros = 0;
     ssize_t offset; // TODO doesn't dump if # entries exceeds SSIZE_MAX
     for (offset = 0; offset < (ssize_t)numberOfEntries && count < lines; ++offset) {
         const size_t idx = (mIdx + numberOfEntries - offset - 1) % numberOfEntries;
                                                                                 // reverse direction
         const int64_t time = mEntries[idx].first;
         const float energy = mEntries[idx].second;

         if (state == AT_END) {
             if (energy == 0.f) {
                 ALOGV("two zeroes detected");
                 break; // normally single zero terminated - two zeroes means no more data.
             }
             state = IN_SIGNAL;
         } else { // IN_SIGNAL
             if (energy == 0.f) {
                 if (column != 0) {
                     column = 0;
                     ++count;
                 }
                 state = AT_END;
                 continue;
             }
         }
         if (column == 0 && time < limitNs) {
             break;
         }
         ++nonzeros;
         if (++column == maxColumns) {
             column = 0;
             // TODO ideally we would peek the previous entry to see if it is 0
             // to ensure we properly put in a starting signal bracket.
             // We don't do that because it would complicate the logic here.
             ++count;
         }
     }
     if (offset > 0) {
         --offset;
     }
     // We accumulate the log info into a string, and write to the fd once.
     std::stringstream ss;
     ss << std::fixed << std::setprecision(1);
     // ss << std::scientific;
     if (nonzeros == 0) {
         ss << prefix << "Signal power history: (none)\n";
     } else {
         // First value is power, second value is whether value is start of
         // a new time stamp.
         std::vector<std::pair<float, bool>> plotEntries;
         ss << prefix << "Signal power history:\n";

         size_t column = 0;
         bool first = true;
         bool start = false;
         float cumulative = 0.f;
         for (; offset >= 0; --offset) {
             const size_t idx = (mIdx + numberOfEntries - offset - 1) % numberOfEntries;
             const int64_t time = mEntries[idx].first;
             const float energy = mEntries[idx].second;

             if (energy == 0.f) {
                 if (!first) {
                     ss << " ] sum(" << audio_utils_power_from_energy(cumulative) << ")";
                     // Add an entry to denote the start of a new time stamp series.
                     if (!plotEntries.empty()) {
                         // First value should be between min and max of all graph entries
                         // so that it doesn't mess with y-axis scaling.
                         plotEntries.emplace_back(plotEntries.back().first, true);
                     }
                 }
                 cumulative = 0.f;
                 column = 0;
                 start = true;
                 continue;
             }
             if (column == 0) {
                 // print time if at start of column
                 if (!first) {
                     ss << "\n";
                 }
                 ss << prefix << " " << audio_utils_time_string_from_ns(time).time
                         << (start ? ": [ ": ":   ");
                 first = false;
                 start = false;
             }  else {
                 ss << " ";
             }
             if (++column >= maxColumns) {
                 column = 0;
             }

             cumulative += energy;
             // convert energy to power and print
             const float power =
                     audio_utils_power_from_energy(energy / (mChannelCount * mFramesPerEntry));
             ss << std::setw(6) << power;
             ALOGV("state: %d %lld %f", state, (long long)time, power);
             // Add an entry to the ASCII art power log graph.
             // false indicates the value doesn't have a new series time stamp.
             plotEntries.emplace_back(power, false);
         }
         ss << "\n" << audio_utils_log_plot(plotEntries.begin(), plotEntries.end());
         ss << "\n";
     }
     return ss.str();
 }

 status_t PowerLog::dump(int fd, const char *prefix, size_t lines, int64_t limitNs) const
 {
     // Since dumpToString and write are thread safe, this function
     // is conceptually thread-safe but simultaneous calls to dump
     // by different threads to the same file descriptor may not write
     // the two logs in time order.
     const std::string s = dumpToString(prefix, lines, limitNs);
     if (s.size() > 0 && write(fd, s.c_str(), s.size()) < 0) {
         return -errno;
     }
     return NO_ERROR;
 }

 } // namespace android

 using namespace android;

 power_log_t *power_log_create(uint32_t sample_rate,
         uint32_t channel_count, audio_format_t format, size_t entries, size_t frames_per_entry)
 {
     if (!audio_utils_is_compute_power_format_supported(format)) {
         return nullptr;
     }
     return reinterpret_cast<power_log_t *>
             (new(std::nothrow)
                     PowerLog(sample_rate, channel_count, format, entries, frames_per_entry));
 }

 void power_log_log(power_log_t *power_log,
         const void *buffer, size_t frames, int64_t now_ns)
 {
     if (power_log == nullptr) {
         return;
     }
     reinterpret_cast<PowerLog *>(power_log)->log(buffer, frames, now_ns);
 }

 int power_log_dump(
         power_log_t *power_log, int fd, const char *prefix, size_t lines, int64_t limit_ns)
 {
     if (power_log == nullptr) {
         return BAD_VALUE;
     }
     return reinterpret_cast<PowerLog *>(power_log)->dump(fd, prefix, lines, limit_ns);
 }

 void power_log_destroy(power_log_t *power_log)
 {
     delete reinterpret_cast<PowerLog *>(power_log);
 }
	/*
	* Copyright 2017 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 "audio_utils_PowerLog"
	#include <log/log.h>

	#include <algorithm>
	#include <iomanip>
	#include <math.h>
	#include <sstream>
	#include <stdint.h>
	#include <unistd.h>
	#include <vector>

	#include <audio_utils/clock.h>
	#include <audio_utils/LogPlot.h>
	#include <audio_utils/power.h>
	#include <audio_utils/PowerLog.h>

	namespace android {

	// TODO move to separate file
	template <typename T, size_t N>
	constexpr size_t array_size(const T(&)[N])
	{
	return N;
	}

	PowerLog::PowerLog(uint32_t sampleRate,
	uint32_t channelCount,
	audio_format_t format,
	size_t entries,
	size_t framesPerEntry)
	: mCurrentTime(0)
	, mCurrentEnergy(0)
	, mCurrentFrames(0)
	, mIdx(0)
	, mConsecutiveZeroes(0)
	, mSampleRate(sampleRate)
	, mChannelCount(channelCount)
	, mFormat(format)
	, mFramesPerEntry(framesPerEntry)
	, mEntries(entries)
	{
	(void)mSampleRate; // currently unused, for future use
	LOG_ALWAYS_FATAL_IF(!audio_utils_is_compute_power_format_supported(format),
	"unsupported format: %#x", format);
	}

	void PowerLog::log(const void *buffer, size_t frames, int64_t nowNs)
	{
	std::lock_guard<std::mutex> guard(mLock);

	const size_t bytes_per_sample = audio_bytes_per_sample(mFormat);
	while (frames > 0) {
	// check partial computation
	size_t required = mFramesPerEntry - mCurrentFrames;
	size_t process = std::min(required, frames);

	if (mCurrentTime == 0) {
	mCurrentTime = nowNs;
	}
	mCurrentEnergy +=
	audio_utils_compute_energy_mono(buffer, mFormat, process * mChannelCount);
	mCurrentFrames += process;

	ALOGV("nowNs:%lld, required:%zu, process:%zu, mCurrentEnergy:%f, mCurrentFrames:%zu",
	(long long)nowNs, required, process, mCurrentEnergy, mCurrentFrames);
	if (process < required) {
	return;
	}

	// We store the data as normalized energy per sample. The energy sequence is
	// zero terminated. Consecutive zeroes are ignored.
	if (mCurrentEnergy == 0.f) {
	if (mConsecutiveZeroes++ == 0) {
	mEntries[mIdx++] = std::make_pair(nowNs, 0.f);
	// zero terminate the signal sequence.
	}
	} else {
	mConsecutiveZeroes = 0;
	mEntries[mIdx++] = std::make_pair(mCurrentTime, mCurrentEnergy);
	ALOGV("writing %lld %f", (long long)mCurrentTime, mCurrentEnergy);
	}
	if (mIdx >= mEntries.size()) {
	mIdx -= mEntries.size();
	}
	mCurrentTime = 0;
	mCurrentEnergy = 0;
	mCurrentFrames = 0;
	frames -= process;
	buffer = (const uint8_t )buffer + mCurrentFrames mChannelCount * bytes_per_sample;
	}
	}

	std::string PowerLog::dumpToString(const char *prefix, size_t lines, int64_t limitNs) const
	{
	std::lock_guard<std::mutex> guard(mLock);

	const size_t maxColumns = 10;
	const size_t numberOfEntries = mEntries.size();
	if (lines == 0) lines = SIZE_MAX;

	// compute where to start logging
	enum {
	AT_END,
	IN_SIGNAL,
	} state = IN_SIGNAL;
	size_t count = 1;
	size_t column = 0;
	size_t nonzeros = 0;
	ssize_t offset; // TODO doesn't dump if # entries exceeds SSIZE_MAX
	for (offset = 0; offset < (ssize_t)numberOfEntries && count < lines; ++offset) {
	const size_t idx = (mIdx + numberOfEntries - offset - 1) % numberOfEntries;
	// reverse direction
	const int64_t time = mEntries[idx].first;
	const float energy = mEntries[idx].second;

	if (state == AT_END) {
	if (energy == 0.f) {
	ALOGV("two zeroes detected");
	break; // normally single zero terminated - two zeroes means no more data.
	}
	state = IN_SIGNAL;
	} else { // IN_SIGNAL
	if (energy == 0.f) {
	if (column != 0) {
	column = 0;
	++count;
	}
	state = AT_END;
	continue;
	}
	}
	if (column == 0 && time < limitNs) {
	break;
	}
	++nonzeros;
	if (++column == maxColumns) {
	column = 0;
	// TODO ideally we would peek the previous entry to see if it is 0
	// to ensure we properly put in a starting signal bracket.
	// We don't do that because it would complicate the logic here.
	++count;
	}
	}
	if (offset > 0) {
	--offset;
	}
	// We accumulate the log info into a string, and write to the fd once.
	std::stringstream ss;
	ss << std::fixed << std::setprecision(1);
	// ss << std::scientific;
	if (nonzeros == 0) {
	ss << prefix << "Signal power history: (none)\n";
	} else {
	// First value is power, second value is whether value is start of
	// a new time stamp.
	std::vector<std::pair<float, bool>> plotEntries;
	ss << prefix << "Signal power history:\n";

	size_t column = 0;
	bool first = true;
	bool start = false;
	float cumulative = 0.f;
	for (; offset >= 0; --offset) {
	const size_t idx = (mIdx + numberOfEntries - offset - 1) % numberOfEntries;
	const int64_t time = mEntries[idx].first;
	const float energy = mEntries[idx].second;

	if (energy == 0.f) {
	if (!first) {
	ss << " ] sum(" << audio_utils_power_from_energy(cumulative) << ")";
	// Add an entry to denote the start of a new time stamp series.
	if (!plotEntries.empty()) {
	// First value should be between min and max of all graph entries
	// so that it doesn't mess with y-axis scaling.
	plotEntries.emplace_back(plotEntries.back().first, true);
	}
	}
	cumulative = 0.f;
	column = 0;
	start = true;
	continue;
	}
	if (column == 0) {
	// print time if at start of column
	if (!first) {
	ss << "\n";
	}
	ss << prefix << " " << audio_utils_time_string_from_ns(time).time
	<< (start ? ": [ ": ": ");
	first = false;
	start = false;
	} else {
	ss << " ";
	}
	if (++column >= maxColumns) {
	column = 0;
	}

	cumulative += energy;
	// convert energy to power and print
	const float power =
	audio_utils_power_from_energy(energy / (mChannelCount * mFramesPerEntry));
	ss << std::setw(6) << power;
	ALOGV("state: %d %lld %f", state, (long long)time, power);
	// Add an entry to the ASCII art power log graph.
	// false indicates the value doesn't have a new series time stamp.
	plotEntries.emplace_back(power, false);
	}
	ss << "\n" << audio_utils_log_plot(plotEntries.begin(), plotEntries.end());
	ss << "\n";
	}
	return ss.str();
	}

	status_t PowerLog::dump(int fd, const char *prefix, size_t lines, int64_t limitNs) const
	{
	// Since dumpToString and write are thread safe, this function
	// is conceptually thread-safe but simultaneous calls to dump
	// by different threads to the same file descriptor may not write
	// the two logs in time order.
	const std::string s = dumpToString(prefix, lines, limitNs);
	if (s.size() > 0 && write(fd, s.c_str(), s.size()) < 0) {
	return -errno;
	}
	return NO_ERROR;
	}

	} // namespace android

	using namespace android;

	power_log_t *power_log_create(uint32_t sample_rate,
	uint32_t channel_count, audio_format_t format, size_t entries, size_t frames_per_entry)
	{
	if (!audio_utils_is_compute_power_format_supported(format)) {
	return nullptr;
	}
	return reinterpret_cast<power_log_t *>
	(new(std::nothrow)
	PowerLog(sample_rate, channel_count, format, entries, frames_per_entry));
	}

	void power_log_log(power_log_t *power_log,
	const void *buffer, size_t frames, int64_t now_ns)
	{
	if (power_log == nullptr) {
	return;
	}
	reinterpret_cast<PowerLog *>(power_log)->log(buffer, frames, now_ns);
	}

	int power_log_dump(
	power_log_t power_log, int fd, const char prefix, size_t lines, int64_t limit_ns)
	{
	if (power_log == nullptr) {
	return BAD_VALUE;
	}
	return reinterpret_cast<PowerLog *>(power_log)->dump(fd, prefix, lines, limit_ns);
	}

	void power_log_destroy(power_log_t *power_log)
	{
	delete reinterpret_cast<PowerLog *>(power_log);
	}