camera/list_qemu_cameras.cpp - device/generic/goldfish - Git at Google

 /*
  * Copyright (C) 2023 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.
  */

 #include <algorithm>
 #include <charconv>
 #include <numeric>
 #include <string_view>
 #include <math.h>

 #include <log/log.h>

 #include "debug.h"
 #include "list_qemu_cameras.h"
 #include "QemuCamera.h"
 #include "qemu_channel.h"

 namespace android {
 namespace hardware {
 namespace camera {
 namespace provider {
 namespace implementation {
 namespace hw {
 namespace {
 bool findToken(const std::string_view str, const std::string_view key, std::string_view* value) {
     size_t pos = 0;
     while (true) {
         pos = str.find(key, pos);
         if (pos == std::string_view::npos) {
             return false;
         } else if ((!pos || str[pos - 1] == ' ') &&
                 (str.size() >= (pos + key.size() + 1)) &&
                 (str[pos + key.size()] == '=')) {
             const size_t vbegin = pos + key.size() + 1;
             const size_t vend = str.find(' ', vbegin);
             if (vend == std::string_view::npos) {
                 *value = str.substr(vbegin, str.size() - vbegin);
             } else {
                 *value = str.substr(vbegin, vend - vbegin);
             }
             return true;
         } else {
             ++pos;
         }
     }
 }

 bool parseResolutions(const std::string_view str, std::vector<Rect<uint16_t>>* supportedResolutions) {
     const char* i = &*str.begin();
     const char* const end = &*str.end();
     if (i == end) {
         return FAILURE(false);
     }

     while (true) {
         Rect<uint16_t> resolution;
         std::from_chars_result r =  std::from_chars(i, end, resolution.width, 10);
         if (r.ec != std::errc()) {
             return FAILURE(false);
         }
         i = r.ptr;
         if (i == end) {
             return FAILURE(false);
         }
         if (*i != 'x') {
             return FAILURE(false);
         }
         r =  std::from_chars(i + 1, end, resolution.height, 10);
         if (r.ec != std::errc()) {
             return FAILURE(false);
         }
         i = r.ptr;

         if ((resolution.width > 0) && (resolution.height > 0)) {
             supportedResolutions->push_back(resolution);
         }

         if (i == end) {
             break;
         } else {
             if (*i == ',') {
                 ++i;
             } else {
                 return FAILURE(false);
             }
         }
     }

     return true;
 }

 Rect<uint16_t> calcThumbnailResolution(const double aspectRatio,
                                        const size_t targetArea) {
     // round to a multiple of 16, a tad down
     const uint16_t height =
         ((uint16_t(sqrt(targetArea / aspectRatio)) + 7) >> 4) << 4;

     // round width to be even
     const uint16_t width = (uint16_t(height * aspectRatio + 1) >> 1) << 1;

     return {width, height};
 }

 struct RectAreaComparator {
     bool operator()(Rect<uint16_t> lhs, Rect<uint16_t> rhs) const {
         const size_t lArea = lhs.area();
         const size_t rArea = rhs.area();

         if (lArea < rArea) {
             return true;
         } else if (lArea > rArea) {
             return false;
         } else {
             return lhs.width < rhs.width;
         }
     }
 };

 } // namespace

 bool listQemuCameras(const std::function<void(HwCameraFactory)>& cameraSink) {
     using namespace std::literals;
     static const char kListQuery[] = "list";

     const auto fd = qemuOpenChannel();
     if (!fd.ok()) { return false; }

     std::vector<uint8_t> data;
     if (qemuRunQuery(fd.get(), kListQuery, sizeof(kListQuery), &data) < 0) {
         return FAILURE(false);
     }

     const char* i = reinterpret_cast<const char*>(&*data.begin());
     const char* const end = reinterpret_cast<const char*>(&*data.end());

     while (i < end) {
         const char* const lf = std::find(i, end, '\n');
         if (lf == end) {
             if (*i) {
                 return FAILURE(false);
             } else {
                 break;
             }
         }

         // line='name=virtualscene channel=0 pix=876758866 dir=back framedims=640x480,352x288,320x240,176x144,1280x720,1280x960'
         const std::string_view line(i, lf - i);

         std::string_view name;
         if (!findToken(line, "name"sv, &name)) { return false; }

         std::string_view dir;
         if (!findToken(line, "dir"sv, &dir)) { return FAILURE(false); }

         std::string_view framedims;
         if (!findToken(line, "framedims"sv, &framedims)) { return FAILURE(false); }

         QemuCamera::Parameters params;
         if (!parseResolutions(framedims, &params.supportedResolutions)) {
             return FAILURE(false);
         }

         if (params.supportedResolutions.empty()) {
             return FAILURE(false);
         } else {
             std::sort(params.supportedResolutions.begin(),
                       params.supportedResolutions.end(),
                       RectAreaComparator());

             std::vector<Rect<uint16_t>> thumbnailResolutions;
             thumbnailResolutions.push_back({0, 0});

             for (const Rect<uint16_t> res : params.supportedResolutions) {
                 const double aspectRatio = double(res.width) / res.height;
                 const size_t resArea4 = res.area() / 4;
                 Rect<uint16_t> thumbnailRes;
                 size_t thumbnailResArea;

                 do {
                     thumbnailRes = calcThumbnailResolution(aspectRatio, 4900);
                     thumbnailResArea = thumbnailRes.area();
                     if ((thumbnailResArea > 0) && (thumbnailResArea < resArea4)) {
                         thumbnailResolutions.push_back(thumbnailRes);
                     } else {
                         thumbnailRes = calcThumbnailResolution(aspectRatio, 1800);
                         thumbnailResArea = thumbnailRes.area();
                         if ((thumbnailResArea > 0) && (thumbnailRes.area() < resArea4)) {
                             thumbnailResolutions.push_back(thumbnailRes);
                         } else {
                             // `res` is too small for a thumbnail
                         }
                         break;
                     }

                     thumbnailRes = calcThumbnailResolution(aspectRatio, 19500);
                     thumbnailResArea = thumbnailRes.area();
                     if ((thumbnailResArea > 0) && (thumbnailRes.area() < resArea4)) {
                         thumbnailResolutions.push_back(thumbnailRes);
                     } else {
                         break;
                     }

                     thumbnailRes = calcThumbnailResolution(aspectRatio, 77000);
                     thumbnailResArea = thumbnailRes.area();
                     if ((thumbnailResArea > 0) && (thumbnailRes.area() < resArea4)) {
                         thumbnailResolutions.push_back(thumbnailRes);
                     }
                 } while (false);
             }

             std::sort(thumbnailResolutions.begin(), thumbnailResolutions.end(),
                       RectAreaComparator());

             thumbnailResolutions.erase(std::unique(thumbnailResolutions.begin(),
                                                    thumbnailResolutions.end()),
                                        thumbnailResolutions.end());

             params.availableThumbnailResolutions = std::move(thumbnailResolutions);
         }

         ALOGD("%s:%d found a '%.*s' QEMU camera, dir=%.*s framedims=%.*s",
               __func__, __LINE__,
               int(name.size()), name.data(),
               int(dir.size()), dir.data(),
               int(framedims.size()), framedims.data());

         params.name = std::string(name.begin(), name.end());

         params.sensorSize = std::accumulate(
             std::next(params.supportedResolutions.begin()),
             params.supportedResolutions.end(),
             params.supportedResolutions.front(),
             [](Rect<uint16_t> z, Rect<uint16_t> x) -> Rect<uint16_t> {
                 return {std::max(z.width, x.width),
                         std::max(z.height, x.height)};
         });

         params.isBackFacing = (dir == "back"sv);

         cameraSink([params = std::move(params)]() {
             return std::make_unique<QemuCamera>(params);
         });

         i = lf + 1;
     }

     return true;
 }

 }  // namespace hw
 }  // namespace implementation
 }  // namespace provider
 }  // namespace camera
 }  // namespace hardware
 }  // namespace android
	/*
	* Copyright (C) 2023 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.
	*/

	#include <algorithm>
	#include <charconv>
	#include <numeric>
	#include <string_view>
	#include <math.h>

	#include <log/log.h>

	#include "debug.h"
	#include "list_qemu_cameras.h"
	#include "QemuCamera.h"
	#include "qemu_channel.h"

	namespace android {
	namespace hardware {
	namespace camera {
	namespace provider {
	namespace implementation {
	namespace hw {
	namespace {
	bool findToken(const std::string_view str, const std::string_view key, std::string_view* value) {
	size_t pos = 0;
	while (true) {
	pos = str.find(key, pos);
	if (pos == std::string_view::npos) {
	return false;
	} else if ((!pos \|\| str[pos - 1] == ' ') &&
	(str.size() >= (pos + key.size() + 1)) &&
	(str[pos + key.size()] == '=')) {
	const size_t vbegin = pos + key.size() + 1;
	const size_t vend = str.find(' ', vbegin);
	if (vend == std::string_view::npos) {
	*value = str.substr(vbegin, str.size() - vbegin);
	} else {
	*value = str.substr(vbegin, vend - vbegin);
	}
	return true;
	} else {
	++pos;
	}
	}
	}

	bool parseResolutions(const std::string_view str, std::vector<Rect<uint16_t>>* supportedResolutions) {
	const char* i = &*str.begin();
	const char* const end = &*str.end();
	if (i == end) {
	return FAILURE(false);
	}

	while (true) {
	Rect<uint16_t> resolution;
	std::from_chars_result r = std::from_chars(i, end, resolution.width, 10);
	if (r.ec != std::errc()) {
	return FAILURE(false);
	}
	i = r.ptr;
	if (i == end) {
	return FAILURE(false);
	}
	if (*i != 'x') {
	return FAILURE(false);
	}
	r = std::from_chars(i + 1, end, resolution.height, 10);
	if (r.ec != std::errc()) {
	return FAILURE(false);
	}
	i = r.ptr;

	if ((resolution.width > 0) && (resolution.height > 0)) {
	supportedResolutions->push_back(resolution);
	}

	if (i == end) {
	break;
	} else {
	if (*i == ',') {
	++i;
	} else {
	return FAILURE(false);
	}
	}
	}

	return true;
	}

	Rect<uint16_t> calcThumbnailResolution(const double aspectRatio,
	const size_t targetArea) {
	// round to a multiple of 16, a tad down
	const uint16_t height =
	((uint16_t(sqrt(targetArea / aspectRatio)) + 7) >> 4) << 4;

	// round width to be even
	const uint16_t width = (uint16_t(height * aspectRatio + 1) >> 1) << 1;

	return {width, height};
	}

	struct RectAreaComparator {
	bool operator()(Rect<uint16_t> lhs, Rect<uint16_t> rhs) const {
	const size_t lArea = lhs.area();
	const size_t rArea = rhs.area();

	if (lArea < rArea) {
	return true;
	} else if (lArea > rArea) {
	return false;
	} else {
	return lhs.width < rhs.width;
	}
	}
	};

	} // namespace

	bool listQemuCameras(const std::function<void(HwCameraFactory)>& cameraSink) {
	using namespace std::literals;
	static const char kListQuery[] = "list";

	const auto fd = qemuOpenChannel();
	if (!fd.ok()) { return false; }

	std::vector<uint8_t> data;
	if (qemuRunQuery(fd.get(), kListQuery, sizeof(kListQuery), &data) < 0) {
	return FAILURE(false);
	}

	const char* i = reinterpret_cast<const char>(&data.begin());
	const char* const end = reinterpret_cast<const char>(&data.end());

	while (i < end) {
	const char* const lf = std::find(i, end, '\n');
	if (lf == end) {
	if (*i) {
	return FAILURE(false);
	} else {
	break;
	}
	}

	// line='name=virtualscene channel=0 pix=876758866 dir=back framedims=640x480,352x288,320x240,176x144,1280x720,1280x960'
	const std::string_view line(i, lf - i);

	std::string_view name;
	if (!findToken(line, "name"sv, &name)) { return false; }

	std::string_view dir;
	if (!findToken(line, "dir"sv, &dir)) { return FAILURE(false); }

	std::string_view framedims;
	if (!findToken(line, "framedims"sv, &framedims)) { return FAILURE(false); }

	QemuCamera::Parameters params;
	if (!parseResolutions(framedims, &params.supportedResolutions)) {
	return FAILURE(false);
	}

	if (params.supportedResolutions.empty()) {
	return FAILURE(false);
	} else {
	std::sort(params.supportedResolutions.begin(),
	params.supportedResolutions.end(),
	RectAreaComparator());

	std::vector<Rect<uint16_t>> thumbnailResolutions;
	thumbnailResolutions.push_back({0, 0});

	for (const Rect<uint16_t> res : params.supportedResolutions) {
	const double aspectRatio = double(res.width) / res.height;
	const size_t resArea4 = res.area() / 4;
	Rect<uint16_t> thumbnailRes;
	size_t thumbnailResArea;

	do {
	thumbnailRes = calcThumbnailResolution(aspectRatio, 4900);
	thumbnailResArea = thumbnailRes.area();
	if ((thumbnailResArea > 0) && (thumbnailResArea < resArea4)) {
	thumbnailResolutions.push_back(thumbnailRes);
	} else {
	thumbnailRes = calcThumbnailResolution(aspectRatio, 1800);
	thumbnailResArea = thumbnailRes.area();
	if ((thumbnailResArea > 0) && (thumbnailRes.area() < resArea4)) {
	thumbnailResolutions.push_back(thumbnailRes);
	} else {
	// `res` is too small for a thumbnail
	}
	break;
	}

	thumbnailRes = calcThumbnailResolution(aspectRatio, 19500);
	thumbnailResArea = thumbnailRes.area();
	if ((thumbnailResArea > 0) && (thumbnailRes.area() < resArea4)) {
	thumbnailResolutions.push_back(thumbnailRes);
	} else {
	break;
	}

	thumbnailRes = calcThumbnailResolution(aspectRatio, 77000);
	thumbnailResArea = thumbnailRes.area();
	if ((thumbnailResArea > 0) && (thumbnailRes.area() < resArea4)) {
	thumbnailResolutions.push_back(thumbnailRes);
	}
	} while (false);
	}

	std::sort(thumbnailResolutions.begin(), thumbnailResolutions.end(),
	RectAreaComparator());

	thumbnailResolutions.erase(std::unique(thumbnailResolutions.begin(),
	thumbnailResolutions.end()),
	thumbnailResolutions.end());

	params.availableThumbnailResolutions = std::move(thumbnailResolutions);
	}

	ALOGD("%s:%d found a '%.s' QEMU camera, dir=%.s framedims=%.*s",
	__func__, __LINE__,
	int(name.size()), name.data(),
	int(dir.size()), dir.data(),
	int(framedims.size()), framedims.data());

	params.name = std::string(name.begin(), name.end());

	params.sensorSize = std::accumulate(
	std::next(params.supportedResolutions.begin()),
	params.supportedResolutions.end(),
	params.supportedResolutions.front(),
	[](Rect<uint16_t> z, Rect<uint16_t> x) -> Rect<uint16_t> {
	return {std::max(z.width, x.width),
	std::max(z.height, x.height)};
	});

	params.isBackFacing = (dir == "back"sv);

	cameraSink([params = std::move(params)]() {
	return std::make_unique<QemuCamera>(params);
	});

	i = lf + 1;
	}

	return true;
	}

	} // namespace hw
	} // namespace implementation
	} // namespace provider
	} // namespace camera
	} // namespace hardware
	} // namespace android