camera/hal_adapter/camera_metadata_inspector.cc - mirrors/cros/chromiumos/platform2 - Git at Google

 /*
  * Copyright 2019 The Chromium OS Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */

 #include "hal_adapter/camera_metadata_inspector.h"

 #include <algorithm>
 #include <utility>

 #include <base/bind.h>
 #include <base/command_line.h>
 #include <base/memory/ptr_util.h>
 #include <base/strings/string_util.h>
 #include <base/strings/stringprintf.h>
 #include <system/camera_metadata.h>

 #include "cros-camera/common.h"

 namespace {

 const char kSeparator[] = " | ";
 const int kSeparatorWidth = 3;

 const char kArrow[] = " => ";
 const int kArrowWidth = 4;

 const char kEllipsis[] = "...";
 const int kEllipsisWidth = 3;

 // The ASCII escape color code for request metadata. It's green.
 const int kRequestColor = 32;

 // The ASCII escape color code for result metadata. It's yellow.
 const int kResultColor = 33;

 // The max column width for an output line.
 const int kMaxLineWidth = 100;

 // The format is HH:MM:ss.SSS, such as 23:59:59.999.
 const int kTimestampWidth = 12;

 // The format is (Req|Res)(frame % 1000), such as Req087.
 const int kIdentifierWidth = 6;

 // The length of the longest request/result key name (lensShadingCorrectionMap).
 const int kMaxKeyWidth = 24;

 // The remaining line width is the space for value.
 const int kMaxValueWidth =
     kMaxLineWidth - (kTimestampWidth + kSeparatorWidth + kIdentifierWidth +
                      kSeparatorWidth + kMaxKeyWidth + kSeparatorWidth);

 // Formats the key of |entry| as {tag_section}.{tag_name}.  Returns empty string
 // on error.
 std::string FormatEntryKey(const camera_metadata_ro_entry_t& entry) {
   const char* tag_section = get_camera_metadata_section_name(entry.tag);
   if (tag_section == nullptr) {
     LOGF(ERROR) << "Failed to get section name of " << entry.tag;
     return "";
   }

   const char* tag_name = get_camera_metadata_tag_name(entry.tag);
   if (tag_name == nullptr) {
     LOGF(ERROR) << "Failed to get tag name of " << entry.tag;
     return "";
   }

   return base::StringPrintf("%s.%s", tag_section, tag_name);
 }

 // Formats the value at index |idx| of |entry| according to its type.  Uses the
 // name of enum if possible, and falls back to numeric value if not found.
 // Returns empty string on error.
 std::string FormatEntryValueAt(const camera_metadata_ro_entry_t& entry,
                                size_t idx) {
   switch (entry.type) {
     case TYPE_BYTE: {
       uint8_t val = entry.data.u8[idx];
       char buf[64];
       if (camera_metadata_enum_snprint(entry.tag, val, buf, sizeof(buf)) == 0) {
         return buf;
       }
       return std::to_string(val);
     }
     case TYPE_INT32: {
       int32_t val = entry.data.i32[idx];
       char buf[64];
       if (camera_metadata_enum_snprint(entry.tag, val, buf, sizeof(buf)) == 0) {
         return buf;
       }
       return std::to_string(val);
     }
     case TYPE_INT64:
       return std::to_string(entry.data.i64[idx]);
     case TYPE_FLOAT:
       return base::StringPrintf("%.2g", entry.data.f[idx]);
     case TYPE_DOUBLE:
       return base::StringPrintf("%.2g", entry.data.d[idx]);
     case TYPE_RATIONAL: {
       camera_metadata_rational_t val = entry.data.r[idx];
       return base::StringPrintf("%d/%d", val.numerator, val.denominator);
     }
     default:
       LOGF(ERROR) << "Unknown entry type " << entry.type;
       return "";
   }
 }

 }  // namespace

 namespace cros {

 std::string DiffData::FormatKey(int width) {
   DCHECK_GE(width, kEllipsisWidth);
   if (width >= key.size()) {
     return key;
   }
   auto dot_pos = key.find('.', key.size() - width - 1);
   if (dot_pos != std::string::npos) {
     return key.substr(dot_pos + 1);
   } else {
     return kEllipsis + key.substr(key.size() - (width - kEllipsisWidth));
   }
 }

 std::string DiffData::FormatValue(int width) {
   DCHECK_GE(width, kEllipsisWidth + kArrowWidth + kEllipsisWidth);

   int old_width = old_val.size();
   int new_width = new_val.size();
   int limit = width - kArrowWidth;

   if (old_width + new_width > limit) {
     if (std::min(old_width, new_width) * 2 <= limit) {
       // It can fit into |limit| by only trimming the longer one.
       if (old_width > new_width) {
         old_width = limit - new_width;
       } else {
         new_width = limit - old_width;
       }
     } else {
       // Distribute the width evenly if we need to trim both.
       old_width = limit / 2;
       new_width = limit - old_width;
     }
   }

   auto Format = [&](const std::string& s, int w) {
     if (s.size() <= w) {
       return s;
     }
     return s.substr(0, w - kEllipsisWidth) + kEllipsis;
   };

   return Format(old_val, old_width) + kArrow + Format(new_val, new_width);
 }

 // static
 std::unique_ptr<CameraMetadataInspector> CameraMetadataInspector::Create(
     int partial_result_count) {
   auto cl = base::CommandLine::ForCurrentProcess();
   base::FilePath output_path =
       cl->GetSwitchValuePath("metadata_inspector_output");
   if (output_path.empty()) {
     return nullptr;
   }

   base::File output_file = {
       output_path, base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_APPEND};
   if (!output_file.IsValid()) {
     LOGF(ERROR) << "Failed to open output file " << output_path.value();
     return nullptr;
   }

   auto GetRE2FromSwitch = [&](base::StringPiece name) -> std::unique_ptr<RE2> {
     std::string value = cl->GetSwitchValueASCII(name);
     if (value.empty()) {
       return nullptr;
     }
     RE2::Options option;
     option.set_case_sensitive(false);
     return std::make_unique<RE2>(value, option);
   };

   std::unique_ptr<RE2> allowlist =
       GetRE2FromSwitch("metadata_inspector_allowlist");
   if (allowlist && !allowlist->ok()) {
     LOGF(ERROR) << "Failed to build regex for allowlist: "
                 << allowlist->error();
     return nullptr;
   }

   std::unique_ptr<RE2> denylist =
       GetRE2FromSwitch("metadata_inspector_denylist");
   if (denylist && !denylist->ok()) {
     LOGF(ERROR) << "Failed to build regex for denylist: " << denylist->error();
     return nullptr;
   }

   auto thread = std::make_unique<base::Thread>("CameraMetadataInspectorThread");
   if (!thread->Start()) {
     LOGF(ERROR) << "Failed to start thread";
     return nullptr;
   }

   return base::WrapUnique(new CameraMetadataInspector(
       partial_result_count, std::move(output_file), std::move(allowlist),
       std::move(denylist), std::move(thread)));
 }

 CameraMetadataInspector::CameraMetadataInspector(
     int partial_result_count,
     base::File output_file,
     std::unique_ptr<RE2> allowlist,
     std::unique_ptr<RE2> denylist,
     std::unique_ptr<base::Thread> thread)
     : partial_result_count_(partial_result_count),
       output_file_(std::move(output_file)),
       allowlist_(std::move(allowlist)),
       denylist_(std::move(denylist)),
       thread_(std::move(thread)) {
   result_sequence_checker_.DetachFromSequence();
 }

 void CameraMetadataInspector::Write(base::StringPiece msg) {
   output_file_.WriteAtCurrentPos(msg.data(), msg.size());
   output_file_.Flush();
 }

 bool CameraMetadataInspector::ShouldIgnoreKey(const std::string& key) {
   if (key.empty()) {
     return true;
   }
   if (allowlist_ && !RE2::PartialMatch(key, *allowlist_)) {
     return true;
   }
   if (denylist_ && RE2::PartialMatch(key, *denylist_)) {
     return true;
   }
   return false;
 }

 CameraMetadataInspector::DataMap CameraMetadataInspector::MapFromMetadata(
     const camera_metadata_t* metadata) {
   CameraMetadataInspector::DataMap map;
   size_t n = get_camera_metadata_entry_count(metadata);
   for (size_t i = 0; i < n; i++) {
     camera_metadata_ro_entry_t entry;
     int ret = get_camera_metadata_ro_entry(metadata, i, &entry);
     if (ret != 0) {
       LOGF(ERROR) << "Failed to get the metadata entry at " << i;
       continue;
     }
     std::string key = FormatEntryKey(entry);
     if (ShouldIgnoreKey(key)) {
       continue;
     }
     std::vector<std::string> values;
     values.reserve(entry.count);
     for (size_t j = 0; j < entry.count; j++) {
       values.push_back(FormatEntryValueAt(entry, j));
     }
     map[key] = base::JoinString(values, " ");
   }
   return map;
 }

 std::vector<DiffData> CameraMetadataInspector::Compare(const DataMap& old_map,
                                                        const DataMap& new_map) {
   std::vector<std::string> keys;
   for (auto& map : {old_map, new_map}) {
     for (auto& elem : map) {
       keys.push_back(elem.first);
     }
   }
   std::sort(keys.begin(), keys.end());
   keys.erase(std::unique(keys.begin(), keys.end()), keys.end());

   auto GetValue = [&](const DataMap& map, const std::string& key) {
     auto it = map.find(key);
     return it != map.end() ? it->second : "nil";
   };

   std::vector<DiffData> diffs;
   for (const auto& key : keys) {
     std::string old_val = GetValue(old_map, key);
     std::string new_val = GetValue(new_map, key);
     if (old_val != new_val) {
       DiffData diff = {key, old_val, new_val};
       diffs.push_back(diff);
     }
   }

   return diffs;
 }

 void CameraMetadataInspector::InspectOnThread(Kind kind,
                                               const std::string& kind_name,
                                               int color,
                                               base::Time time,
                                               int frame_number,
                                               camera_metadata_t* metadata) {
   DCHECK(thread_->task_runner()->BelongsToCurrentThread());
   auto map = MapFromMetadata(metadata);
   base::Time::Exploded exploded;
   time.LocalExplode(&exploded);
   auto diffs = Compare(latest_map[static_cast<size_t>(kind)], map);
   std::stringstream ss;
   for (auto diff : diffs) {
     ss << "\e[" << color << "m";
     ss << base::StringPrintf("%02d:%02d:%02d.%03d", exploded.hour,
                              exploded.minute, exploded.second,
                              exploded.millisecond);
     ss << kSeparator;
     ss << base::StringPrintf("%s%03d", kind_name.c_str(), frame_number % 1000);
     ss << kSeparator;
     ss << base::StringPrintf("%*s", kMaxKeyWidth,
                              diff.FormatKey(kMaxKeyWidth).c_str());
     ss << kSeparator;
     ss << diff.FormatValue(kMaxValueWidth);
     ss << "\e[0m\n";
   }
   Write(ss.str());
   latest_map[static_cast<size_t>(kind)] = map;
   free_camera_metadata(metadata);
 }

 void CameraMetadataInspector::InspectRequest(
     const camera3_capture_request_t* request) {
   if (request->settings == nullptr) {
     return;
   }
   thread_->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&CameraMetadataInspector::InspectOnThread,
                  base::Unretained(this), Kind::kRequest, "Req", kRequestColor,
                  base::Time::Now(), request->frame_number,
                  clone_camera_metadata(request->settings)));
 }

 void CameraMetadataInspector::InspectResult(
     const camera3_capture_result_t* result) {
   DCHECK(result_sequence_checker_.CalledOnValidSequence());
   if (result->result == nullptr) {
     return;
   }
   pending_result_.append(result->result);
   if (result->partial_result != partial_result_count_) {
     return;
   }
   thread_->task_runner()->PostTask(
       FROM_HERE, base::Bind(&CameraMetadataInspector::InspectOnThread,
                             base::Unretained(this), Kind::kResult, "Res",
                             kResultColor, base::Time::Now(),
                             result->frame_number, pending_result_.release()));
 }

 }  // namespace cros
	/*
	* Copyright 2019 The Chromium OS Authors. All rights reserved.
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*/

	#include "hal_adapter/camera_metadata_inspector.h"

	#include <algorithm>
	#include <utility>

	#include <base/bind.h>
	#include <base/command_line.h>
	#include <base/memory/ptr_util.h>
	#include <base/strings/string_util.h>
	#include <base/strings/stringprintf.h>
	#include <system/camera_metadata.h>

	#include "cros-camera/common.h"

	namespace {

	const char kSeparator[] = " \| ";
	const int kSeparatorWidth = 3;

	const char kArrow[] = " => ";
	const int kArrowWidth = 4;

	const char kEllipsis[] = "...";
	const int kEllipsisWidth = 3;

	// The ASCII escape color code for request metadata. It's green.
	const int kRequestColor = 32;

	// The ASCII escape color code for result metadata. It's yellow.
	const int kResultColor = 33;

	// The max column width for an output line.
	const int kMaxLineWidth = 100;

	// The format is HH:MM:ss.SSS, such as 23:59:59.999.
	const int kTimestampWidth = 12;

	// The format is (Req\|Res)(frame % 1000), such as Req087.
	const int kIdentifierWidth = 6;

	// The length of the longest request/result key name (lensShadingCorrectionMap).
	const int kMaxKeyWidth = 24;

	// The remaining line width is the space for value.
	const int kMaxValueWidth =
	kMaxLineWidth - (kTimestampWidth + kSeparatorWidth + kIdentifierWidth +
	kSeparatorWidth + kMaxKeyWidth + kSeparatorWidth);

	// Formats the key of \|entry\| as {tag_section}.{tag_name}. Returns empty string
	// on error.
	std::string FormatEntryKey(const camera_metadata_ro_entry_t& entry) {
	const char* tag_section = get_camera_metadata_section_name(entry.tag);
	if (tag_section == nullptr) {
	LOGF(ERROR) << "Failed to get section name of " << entry.tag;
	return "";
	}

	const char* tag_name = get_camera_metadata_tag_name(entry.tag);
	if (tag_name == nullptr) {
	LOGF(ERROR) << "Failed to get tag name of " << entry.tag;
	return "";
	}

	return base::StringPrintf("%s.%s", tag_section, tag_name);
	}

	// Formats the value at index \|idx\| of \|entry\| according to its type. Uses the
	// name of enum if possible, and falls back to numeric value if not found.
	// Returns empty string on error.
	std::string FormatEntryValueAt(const camera_metadata_ro_entry_t& entry,
	size_t idx) {
	switch (entry.type) {
	case TYPE_BYTE: {
	uint8_t val = entry.data.u8[idx];
	char buf[64];
	if (camera_metadata_enum_snprint(entry.tag, val, buf, sizeof(buf)) == 0) {
	return buf;
	}
	return std::to_string(val);
	}
	case TYPE_INT32: {
	int32_t val = entry.data.i32[idx];
	char buf[64];
	if (camera_metadata_enum_snprint(entry.tag, val, buf, sizeof(buf)) == 0) {
	return buf;
	}
	return std::to_string(val);
	}
	case TYPE_INT64:
	return std::to_string(entry.data.i64[idx]);
	case TYPE_FLOAT:
	return base::StringPrintf("%.2g", entry.data.f[idx]);
	case TYPE_DOUBLE:
	return base::StringPrintf("%.2g", entry.data.d[idx]);
	case TYPE_RATIONAL: {
	camera_metadata_rational_t val = entry.data.r[idx];
	return base::StringPrintf("%d/%d", val.numerator, val.denominator);
	}
	default:
	LOGF(ERROR) << "Unknown entry type " << entry.type;
	return "";
	}
	}

	} // namespace

	namespace cros {

	std::string DiffData::FormatKey(int width) {
	DCHECK_GE(width, kEllipsisWidth);
	if (width >= key.size()) {
	return key;
	}
	auto dot_pos = key.find('.', key.size() - width - 1);
	if (dot_pos != std::string::npos) {
	return key.substr(dot_pos + 1);
	} else {
	return kEllipsis + key.substr(key.size() - (width - kEllipsisWidth));
	}
	}

	std::string DiffData::FormatValue(int width) {
	DCHECK_GE(width, kEllipsisWidth + kArrowWidth + kEllipsisWidth);

	int old_width = old_val.size();
	int new_width = new_val.size();
	int limit = width - kArrowWidth;

	if (old_width + new_width > limit) {
	if (std::min(old_width, new_width) * 2 <= limit) {
	// It can fit into \|limit\| by only trimming the longer one.
	if (old_width > new_width) {
	old_width = limit - new_width;
	} else {
	new_width = limit - old_width;
	}
	} else {
	// Distribute the width evenly if we need to trim both.
	old_width = limit / 2;
	new_width = limit - old_width;
	}
	}

	auto Format = [&](const std::string& s, int w) {
	if (s.size() <= w) {
	return s;
	}
	return s.substr(0, w - kEllipsisWidth) + kEllipsis;
	};

	return Format(old_val, old_width) + kArrow + Format(new_val, new_width);
	}

	// static
	std::unique_ptr<CameraMetadataInspector> CameraMetadataInspector::Create(
	int partial_result_count) {
	auto cl = base::CommandLine::ForCurrentProcess();
	base::FilePath output_path =
	cl->GetSwitchValuePath("metadata_inspector_output");
	if (output_path.empty()) {
	return nullptr;
	}

	base::File output_file = {
	output_path, base::File::FLAG_OPEN_ALWAYS \| base::File::FLAG_APPEND};
	if (!output_file.IsValid()) {
	LOGF(ERROR) << "Failed to open output file " << output_path.value();
	return nullptr;
	}

	auto GetRE2FromSwitch = [&](base::StringPiece name) -> std::unique_ptr<RE2> {
	std::string value = cl->GetSwitchValueASCII(name);
	if (value.empty()) {
	return nullptr;
	}
	RE2::Options option;
	option.set_case_sensitive(false);
	return std::make_unique<RE2>(value, option);
	};

	std::unique_ptr<RE2> allowlist =
	GetRE2FromSwitch("metadata_inspector_allowlist");
	if (allowlist && !allowlist->ok()) {
	LOGF(ERROR) << "Failed to build regex for allowlist: "
	<< allowlist->error();
	return nullptr;
	}

	std::unique_ptr<RE2> denylist =
	GetRE2FromSwitch("metadata_inspector_denylist");
	if (denylist && !denylist->ok()) {
	LOGF(ERROR) << "Failed to build regex for denylist: " << denylist->error();
	return nullptr;
	}

	auto thread = std::make_unique<base::Thread>("CameraMetadataInspectorThread");
	if (!thread->Start()) {
	LOGF(ERROR) << "Failed to start thread";
	return nullptr;
	}

	return base::WrapUnique(new CameraMetadataInspector(
	partial_result_count, std::move(output_file), std::move(allowlist),
	std::move(denylist), std::move(thread)));
	}

	CameraMetadataInspector::CameraMetadataInspector(
	int partial_result_count,
	base::File output_file,
	std::unique_ptr<RE2> allowlist,
	std::unique_ptr<RE2> denylist,
	std::unique_ptr<base::Thread> thread)
	: partial_result_count_(partial_result_count),
	output_file_(std::move(output_file)),
	allowlist_(std::move(allowlist)),
	denylist_(std::move(denylist)),
	thread_(std::move(thread)) {
	result_sequence_checker_.DetachFromSequence();
	}

	void CameraMetadataInspector::Write(base::StringPiece msg) {
	output_file_.WriteAtCurrentPos(msg.data(), msg.size());
	output_file_.Flush();
	}

	bool CameraMetadataInspector::ShouldIgnoreKey(const std::string& key) {
	if (key.empty()) {
	return true;
	}
	if (allowlist_ && !RE2::PartialMatch(key, *allowlist_)) {
	return true;
	}
	if (denylist_ && RE2::PartialMatch(key, *denylist_)) {
	return true;
	}
	return false;
	}

	CameraMetadataInspector::DataMap CameraMetadataInspector::MapFromMetadata(
	const camera_metadata_t* metadata) {
	CameraMetadataInspector::DataMap map;
	size_t n = get_camera_metadata_entry_count(metadata);
	for (size_t i = 0; i < n; i++) {
	camera_metadata_ro_entry_t entry;
	int ret = get_camera_metadata_ro_entry(metadata, i, &entry);
	if (ret != 0) {
	LOGF(ERROR) << "Failed to get the metadata entry at " << i;
	continue;
	}
	std::string key = FormatEntryKey(entry);
	if (ShouldIgnoreKey(key)) {
	continue;
	}
	std::vector<std::string> values;
	values.reserve(entry.count);
	for (size_t j = 0; j < entry.count; j++) {
	values.push_back(FormatEntryValueAt(entry, j));
	}
	map[key] = base::JoinString(values, " ");
	}
	return map;
	}

	std::vector<DiffData> CameraMetadataInspector::Compare(const DataMap& old_map,
	const DataMap& new_map) {
	std::vector<std::string> keys;
	for (auto& map : {old_map, new_map}) {
	for (auto& elem : map) {
	keys.push_back(elem.first);
	}
	}
	std::sort(keys.begin(), keys.end());
	keys.erase(std::unique(keys.begin(), keys.end()), keys.end());

	auto GetValue = [&](const DataMap& map, const std::string& key) {
	auto it = map.find(key);
	return it != map.end() ? it->second : "nil";
	};

	std::vector<DiffData> diffs;
	for (const auto& key : keys) {
	std::string old_val = GetValue(old_map, key);
	std::string new_val = GetValue(new_map, key);
	if (old_val != new_val) {
	DiffData diff = {key, old_val, new_val};
	diffs.push_back(diff);
	}
	}

	return diffs;
	}

	void CameraMetadataInspector::InspectOnThread(Kind kind,
	const std::string& kind_name,
	int color,
	base::Time time,
	int frame_number,
	camera_metadata_t* metadata) {
	DCHECK(thread_->task_runner()->BelongsToCurrentThread());
	auto map = MapFromMetadata(metadata);
	base::Time::Exploded exploded;
	time.LocalExplode(&exploded);
	auto diffs = Compare(latest_map[static_cast<size_t>(kind)], map);
	std::stringstream ss;
	for (auto diff : diffs) {
	ss << "\e[" << color << "m";
	ss << base::StringPrintf("%02d:%02d:%02d.%03d", exploded.hour,
	exploded.minute, exploded.second,
	exploded.millisecond);
	ss << kSeparator;
	ss << base::StringPrintf("%s%03d", kind_name.c_str(), frame_number % 1000);
	ss << kSeparator;
	ss << base::StringPrintf("%*s", kMaxKeyWidth,
	diff.FormatKey(kMaxKeyWidth).c_str());
	ss << kSeparator;
	ss << diff.FormatValue(kMaxValueWidth);
	ss << "\e[0m\n";
	}
	Write(ss.str());
	latest_map[static_cast<size_t>(kind)] = map;
	free_camera_metadata(metadata);
	}

	void CameraMetadataInspector::InspectRequest(
	const camera3_capture_request_t* request) {
	if (request->settings == nullptr) {
	return;
	}
	thread_->task_runner()->PostTask(
	FROM_HERE,
	base::Bind(&CameraMetadataInspector::InspectOnThread,
	base::Unretained(this), Kind::kRequest, "Req", kRequestColor,
	base::Time::Now(), request->frame_number,
	clone_camera_metadata(request->settings)));
	}

	void CameraMetadataInspector::InspectResult(
	const camera3_capture_result_t* result) {
	DCHECK(result_sequence_checker_.CalledOnValidSequence());
	if (result->result == nullptr) {
	return;
	}
	pending_result_.append(result->result);
	if (result->partial_result != partial_result_count_) {
	return;
	}
	thread_->task_runner()->PostTask(
	FROM_HERE, base::Bind(&CameraMetadataInspector::InspectOnThread,
	base::Unretained(this), Kind::kResult, "Res",
	kResultColor, base::Time::Now(),
	result->frame_number, pending_result_.release()));
	}

	} // namespace cros