camera/device/3.4/default/ExternalCameraUtils.cpp - android_hardware_interfaces - Gitiles

 /*
  * Copyright (C) 2018 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_TAG "ExtCamUtils@3.4"
 //#define LOG_NDEBUG 0
 #include <log/log.h>

 #include <cmath>
 #include <sys/mman.h>
 #include <linux/videodev2.h>
 #include "ExternalCameraUtils.h"
 #include "tinyxml2.h" // XML parsing

 namespace android {
 namespace hardware {
 namespace camera {
 namespace device {
 namespace V3_4 {
 namespace implementation {

 V4L2Frame::V4L2Frame(
         uint32_t w, uint32_t h, uint32_t fourcc,
         int bufIdx, int fd, uint32_t dataSize, uint64_t offset) :
         mWidth(w), mHeight(h), mFourcc(fourcc),
         mBufferIndex(bufIdx), mFd(fd), mDataSize(dataSize), mOffset(offset) {}

 int V4L2Frame::map(uint8_t** data, size_t* dataSize) {
     if (data == nullptr || dataSize == nullptr) {
         ALOGI("%s: V4L2 buffer map bad argument: data %p, dataSize %p",
                 __FUNCTION__, data, dataSize);
         return -EINVAL;
     }

     std::lock_guard<std::mutex> lk(mLock);
     if (!mMapped) {
         void* addr = mmap(NULL, mDataSize, PROT_READ, MAP_SHARED, mFd, mOffset);
         if (addr == MAP_FAILED) {
             ALOGE("%s: V4L2 buffer map failed: %s", __FUNCTION__, strerror(errno));
             return -EINVAL;
         }
         mData = static_cast<uint8_t*>(addr);
         mMapped = true;
     }
     *data = mData;
     *dataSize = mDataSize;
     ALOGV("%s: V4L map FD %d, data %p size %zu", __FUNCTION__, mFd, mData, mDataSize);
     return 0;
 }

 int V4L2Frame::unmap() {
     std::lock_guard<std::mutex> lk(mLock);
     if (mMapped) {
         ALOGV("%s: V4L unmap data %p size %zu", __FUNCTION__, mData, mDataSize);
         if (munmap(mData, mDataSize) != 0) {
             ALOGE("%s: V4L2 buffer unmap failed: %s", __FUNCTION__, strerror(errno));
             return -EINVAL;
         }
         mMapped = false;
     }
     return 0;
 }

 V4L2Frame::~V4L2Frame() {
     unmap();
 }

 AllocatedFrame::AllocatedFrame(
         uint32_t w, uint32_t h) :
         mWidth(w), mHeight(h), mFourcc(V4L2_PIX_FMT_YUV420) {};

 AllocatedFrame::~AllocatedFrame() {}

 int AllocatedFrame::allocate(YCbCrLayout* out) {
     std::lock_guard<std::mutex> lk(mLock);
     if ((mWidth % 2) || (mHeight % 2)) {
         ALOGE("%s: bad dimension %dx%d (not multiple of 2)", __FUNCTION__, mWidth, mHeight);
         return -EINVAL;
     }

     uint32_t dataSize = mWidth * mHeight * 3 / 2; // YUV420
     if (mData.size() != dataSize) {
         mData.resize(dataSize);
     }

     if (out != nullptr) {
         out->y = mData.data();
         out->yStride = mWidth;
         uint8_t* cbStart = mData.data() + mWidth * mHeight;
         uint8_t* crStart = cbStart + mWidth * mHeight / 4;
         out->cb = cbStart;
         out->cr = crStart;
         out->cStride = mWidth / 2;
         out->chromaStep = 1;
     }
     return 0;
 }

 int AllocatedFrame::getLayout(YCbCrLayout* out) {
     IMapper::Rect noCrop = {0, 0,
             static_cast<int32_t>(mWidth),
             static_cast<int32_t>(mHeight)};
     return getCroppedLayout(noCrop, out);
 }

 int AllocatedFrame::getCroppedLayout(const IMapper::Rect& rect, YCbCrLayout* out) {
     if (out == nullptr) {
         ALOGE("%s: null out", __FUNCTION__);
         return -1;
     }

     std::lock_guard<std::mutex> lk(mLock);
     if ((rect.left + rect.width) > static_cast<int>(mWidth) ||
         (rect.top + rect.height) > static_cast<int>(mHeight) ||
             (rect.left % 2) || (rect.top % 2) || (rect.width % 2) || (rect.height % 2)) {
         ALOGE("%s: bad rect left %d top %d w %d h %d", __FUNCTION__,
                 rect.left, rect.top, rect.width, rect.height);
         return -1;
     }

     out->y = mData.data() + mWidth * rect.top + rect.left;
     out->yStride = mWidth;
     uint8_t* cbStart = mData.data() + mWidth * mHeight;
     uint8_t* crStart = cbStart + mWidth * mHeight / 4;
     out->cb = cbStart + mWidth * rect.top / 4 + rect.left / 2;
     out->cr = crStart + mWidth * rect.top / 4 + rect.left / 2;
     out->cStride = mWidth / 2;
     out->chromaStep = 1;
     return 0;
 }

 bool isAspectRatioClose(float ar1, float ar2) {
     const float kAspectRatioMatchThres = 0.025f; // This threshold is good enough to distinguish
                                                 // 4:3/16:9/20:9
                                                 // 1.33 / 1.78 / 2
     return (std::abs(ar1 - ar2) < kAspectRatioMatchThres);
 }

 double SupportedV4L2Format::FrameRate::getDouble() const {
     return durationDenominator / static_cast<double>(durationNumerator);
 }

 }  // namespace implementation
 }  // namespace V3_4
 }  // namespace device


 namespace external {
 namespace common {

 namespace {
     const int  kDefaultJpegBufSize = 5 << 20; // 5MB
     const int  kDefaultNumVideoBuffer = 4;
     const int  kDefaultNumStillBuffer = 2;
 } // anonymous namespace

 const char* ExternalCameraConfig::kDefaultCfgPath = "/vendor/etc/external_camera_config.xml";

 ExternalCameraConfig ExternalCameraConfig::loadFromCfg(const char* cfgPath) {
     using namespace tinyxml2;
     ExternalCameraConfig ret;

     XMLDocument configXml;
     XMLError err = configXml.LoadFile(cfgPath);
     if (err != XML_SUCCESS) {
         ALOGE("%s: Unable to load external camera config file '%s'. Error: %s",
                 __FUNCTION__, cfgPath, XMLDocument::ErrorIDToName(err));
         return ret;
     } else {
         ALOGI("%s: load external camera config succeed!", __FUNCTION__);
     }

     XMLElement *extCam = configXml.FirstChildElement("ExternalCamera");
     if (extCam == nullptr) {
         ALOGI("%s: no external camera config specified", __FUNCTION__);
         return ret;
     }

     XMLElement *providerCfg = extCam->FirstChildElement("Provider");
     if (providerCfg == nullptr) {
         ALOGI("%s: no external camera provider config specified", __FUNCTION__);
         return ret;
     }

     XMLElement *ignore = providerCfg->FirstChildElement("ignore");
     if (ignore == nullptr) {
         ALOGI("%s: no internal ignored device specified", __FUNCTION__);
         return ret;
     }

     XMLElement *id = ignore->FirstChildElement("id");
     while (id != nullptr) {
         const char* text = id->GetText();
         if (text != nullptr) {
             ret.mInternalDevices.insert(text);
             ALOGI("%s: device %s will be ignored by external camera provider",
                     __FUNCTION__, text);
         }
         id = id->NextSiblingElement("id");
     }

     XMLElement *deviceCfg = extCam->FirstChildElement("Device");
     if (deviceCfg == nullptr) {
         ALOGI("%s: no external camera device config specified", __FUNCTION__);
         return ret;
     }

     XMLElement *jpegBufSz = deviceCfg->FirstChildElement("MaxJpegBufferSize");
     if (jpegBufSz == nullptr) {
         ALOGI("%s: no max jpeg buffer size specified", __FUNCTION__);
     } else {
         ret.maxJpegBufSize = jpegBufSz->UnsignedAttribute("bytes", /*Default*/kDefaultJpegBufSize);
     }

     XMLElement *numVideoBuf = deviceCfg->FirstChildElement("NumVideoBuffers");
     if (numVideoBuf == nullptr) {
         ALOGI("%s: no num video buffers specified", __FUNCTION__);
     } else {
         ret.numVideoBuffers =
                 numVideoBuf->UnsignedAttribute("count", /*Default*/kDefaultNumVideoBuffer);
     }

     XMLElement *numStillBuf = deviceCfg->FirstChildElement("NumStillBuffers");
     if (numStillBuf == nullptr) {
         ALOGI("%s: no num still buffers specified", __FUNCTION__);
     } else {
         ret.numStillBuffers =
                 numStillBuf->UnsignedAttribute("count", /*Default*/kDefaultNumStillBuffer);
     }

     XMLElement *fpsList = deviceCfg->FirstChildElement("FpsList");
     if (fpsList == nullptr) {
         ALOGI("%s: no fps list specified", __FUNCTION__);
     } else {
         std::vector<FpsLimitation> limits;
         XMLElement *row = fpsList->FirstChildElement("Limit");
         while (row != nullptr) {
             FpsLimitation prevLimit {{0, 0}, 1000.0};
             FpsLimitation limit;
             limit.size = {
                 row->UnsignedAttribute("width", /*Default*/0),
                 row->UnsignedAttribute("height", /*Default*/0)};
             limit.fpsUpperBound = row->DoubleAttribute("fpsBound", /*Default*/1000.0);
             if (limit.size.width <= prevLimit.size.width ||
                     limit.size.height <= prevLimit.size.height ||
                     limit.fpsUpperBound >= prevLimit.fpsUpperBound) {
                 ALOGE("%s: FPS limit list must have increasing size and decreasing fps!"
                         " Prev %dx%d@%f, Current %dx%d@%f", __FUNCTION__,
                         prevLimit.size.width, prevLimit.size.height, prevLimit.fpsUpperBound,
                         limit.size.width, limit.size.height, limit.fpsUpperBound);
                 return ret;
             }
             limits.push_back(limit);
             row = row->NextSiblingElement("Limit");
         }
         ret.fpsLimits = limits;
     }

     ALOGI("%s: external camera cfg loaded: maxJpgBufSize %d,"
             " num video buffers %d, num still buffers %d",
             __FUNCTION__, ret.maxJpegBufSize,
             ret.numVideoBuffers, ret.numStillBuffers);
     for (const auto& limit : ret.fpsLimits) {
         ALOGI("%s: fpsLimitList: %dx%d@%f", __FUNCTION__,
                 limit.size.width, limit.size.height, limit.fpsUpperBound);
     }
     return ret;
 }

 ExternalCameraConfig::ExternalCameraConfig() :
         maxJpegBufSize(kDefaultJpegBufSize),
         numVideoBuffers(kDefaultNumVideoBuffer),
         numStillBuffers(kDefaultNumStillBuffer) {
     fpsLimits.push_back({/*Size*/{ 640,  480}, /*FPS upper bound*/30.0});
     fpsLimits.push_back({/*Size*/{1280,  720}, /*FPS upper bound*/7.5});
     fpsLimits.push_back({/*Size*/{1920, 1080}, /*FPS upper bound*/5.0});
 }


 }  // namespace common
 }  // namespace external
 }  // namespace camera
 }  // namespace hardware
 }  // namespace android
	/*
	* Copyright (C) 2018 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_TAG "ExtCamUtils@3.4"
	//#define LOG_NDEBUG 0
	#include <log/log.h>

	#include <cmath>
	#include <sys/mman.h>
	#include <linux/videodev2.h>
	#include "ExternalCameraUtils.h"
	#include "tinyxml2.h" // XML parsing

	namespace android {
	namespace hardware {
	namespace camera {
	namespace device {
	namespace V3_4 {
	namespace implementation {

	V4L2Frame::V4L2Frame(
	uint32_t w, uint32_t h, uint32_t fourcc,
	int bufIdx, int fd, uint32_t dataSize, uint64_t offset) :
	mWidth(w), mHeight(h), mFourcc(fourcc),
	mBufferIndex(bufIdx), mFd(fd), mDataSize(dataSize), mOffset(offset) {}

	int V4L2Frame::map(uint8_t** data, size_t* dataSize) {
	if (data == nullptr \|\| dataSize == nullptr) {
	ALOGI("%s: V4L2 buffer map bad argument: data %p, dataSize %p",
	__FUNCTION__, data, dataSize);
	return -EINVAL;
	}

	std::lock_guard<std::mutex> lk(mLock);
	if (!mMapped) {
	void* addr = mmap(NULL, mDataSize, PROT_READ, MAP_SHARED, mFd, mOffset);
	if (addr == MAP_FAILED) {
	ALOGE("%s: V4L2 buffer map failed: %s", __FUNCTION__, strerror(errno));
	return -EINVAL;
	}
	mData = static_cast<uint8_t*>(addr);
	mMapped = true;
	}
	*data = mData;
	*dataSize = mDataSize;
	ALOGV("%s: V4L map FD %d, data %p size %zu", __FUNCTION__, mFd, mData, mDataSize);
	return 0;
	}

	int V4L2Frame::unmap() {
	std::lock_guard<std::mutex> lk(mLock);
	if (mMapped) {
	ALOGV("%s: V4L unmap data %p size %zu", __FUNCTION__, mData, mDataSize);
	if (munmap(mData, mDataSize) != 0) {
	ALOGE("%s: V4L2 buffer unmap failed: %s", __FUNCTION__, strerror(errno));
	return -EINVAL;
	}
	mMapped = false;
	}
	return 0;
	}

	V4L2Frame::~V4L2Frame() {
	unmap();
	}

	AllocatedFrame::AllocatedFrame(
	uint32_t w, uint32_t h) :
	mWidth(w), mHeight(h), mFourcc(V4L2_PIX_FMT_YUV420) {};

	AllocatedFrame::~AllocatedFrame() {}

	int AllocatedFrame::allocate(YCbCrLayout* out) {
	std::lock_guard<std::mutex> lk(mLock);
	if ((mWidth % 2) \|\| (mHeight % 2)) {
	ALOGE("%s: bad dimension %dx%d (not multiple of 2)", __FUNCTION__, mWidth, mHeight);
	return -EINVAL;
	}

	uint32_t dataSize = mWidth * mHeight * 3 / 2; // YUV420
	if (mData.size() != dataSize) {
	mData.resize(dataSize);
	}

	if (out != nullptr) {
	out->y = mData.data();
	out->yStride = mWidth;
	uint8_t* cbStart = mData.data() + mWidth * mHeight;
	uint8_t* crStart = cbStart + mWidth * mHeight / 4;
	out->cb = cbStart;
	out->cr = crStart;
	out->cStride = mWidth / 2;
	out->chromaStep = 1;
	}
	return 0;
	}

	int AllocatedFrame::getLayout(YCbCrLayout* out) {
	IMapper::Rect noCrop = {0, 0,
	static_cast<int32_t>(mWidth),
	static_cast<int32_t>(mHeight)};
	return getCroppedLayout(noCrop, out);
	}

	int AllocatedFrame::getCroppedLayout(const IMapper::Rect& rect, YCbCrLayout* out) {
	if (out == nullptr) {
	ALOGE("%s: null out", __FUNCTION__);
	return -1;
	}

	std::lock_guard<std::mutex> lk(mLock);
	if ((rect.left + rect.width) > static_cast<int>(mWidth) \|\|
	(rect.top + rect.height) > static_cast<int>(mHeight) \|\|
	(rect.left % 2) \|\| (rect.top % 2) \|\| (rect.width % 2) \|\| (rect.height % 2)) {
	ALOGE("%s: bad rect left %d top %d w %d h %d", __FUNCTION__,
	rect.left, rect.top, rect.width, rect.height);
	return -1;
	}

	out->y = mData.data() + mWidth * rect.top + rect.left;
	out->yStride = mWidth;
	uint8_t* cbStart = mData.data() + mWidth * mHeight;
	uint8_t* crStart = cbStart + mWidth * mHeight / 4;
	out->cb = cbStart + mWidth * rect.top / 4 + rect.left / 2;
	out->cr = crStart + mWidth * rect.top / 4 + rect.left / 2;
	out->cStride = mWidth / 2;
	out->chromaStep = 1;
	return 0;
	}

	bool isAspectRatioClose(float ar1, float ar2) {
	const float kAspectRatioMatchThres = 0.025f; // This threshold is good enough to distinguish
	// 4:3/16:9/20:9
	// 1.33 / 1.78 / 2
	return (std::abs(ar1 - ar2) < kAspectRatioMatchThres);
	}

	double SupportedV4L2Format::FrameRate::getDouble() const {
	return durationDenominator / static_cast<double>(durationNumerator);
	}

	} // namespace implementation
	} // namespace V3_4
	} // namespace device


	namespace external {
	namespace common {

	namespace {
	const int kDefaultJpegBufSize = 5 << 20; // 5MB
	const int kDefaultNumVideoBuffer = 4;
	const int kDefaultNumStillBuffer = 2;
	} // anonymous namespace

	const char* ExternalCameraConfig::kDefaultCfgPath = "/vendor/etc/external_camera_config.xml";

	ExternalCameraConfig ExternalCameraConfig::loadFromCfg(const char* cfgPath) {
	using namespace tinyxml2;
	ExternalCameraConfig ret;

	XMLDocument configXml;
	XMLError err = configXml.LoadFile(cfgPath);
	if (err != XML_SUCCESS) {
	ALOGE("%s: Unable to load external camera config file '%s'. Error: %s",
	__FUNCTION__, cfgPath, XMLDocument::ErrorIDToName(err));
	return ret;
	} else {
	ALOGI("%s: load external camera config succeed!", __FUNCTION__);
	}

	XMLElement *extCam = configXml.FirstChildElement("ExternalCamera");
	if (extCam == nullptr) {
	ALOGI("%s: no external camera config specified", __FUNCTION__);
	return ret;
	}

	XMLElement *providerCfg = extCam->FirstChildElement("Provider");
	if (providerCfg == nullptr) {
	ALOGI("%s: no external camera provider config specified", __FUNCTION__);
	return ret;
	}

	XMLElement *ignore = providerCfg->FirstChildElement("ignore");
	if (ignore == nullptr) {
	ALOGI("%s: no internal ignored device specified", __FUNCTION__);
	return ret;
	}

	XMLElement *id = ignore->FirstChildElement("id");
	while (id != nullptr) {
	const char* text = id->GetText();
	if (text != nullptr) {
	ret.mInternalDevices.insert(text);
	ALOGI("%s: device %s will be ignored by external camera provider",
	__FUNCTION__, text);
	}
	id = id->NextSiblingElement("id");
	}

	XMLElement *deviceCfg = extCam->FirstChildElement("Device");
	if (deviceCfg == nullptr) {
	ALOGI("%s: no external camera device config specified", __FUNCTION__);
	return ret;
	}

	XMLElement *jpegBufSz = deviceCfg->FirstChildElement("MaxJpegBufferSize");
	if (jpegBufSz == nullptr) {
	ALOGI("%s: no max jpeg buffer size specified", __FUNCTION__);
	} else {
	ret.maxJpegBufSize = jpegBufSz->UnsignedAttribute("bytes", /Default/kDefaultJpegBufSize);
	}

	XMLElement *numVideoBuf = deviceCfg->FirstChildElement("NumVideoBuffers");
	if (numVideoBuf == nullptr) {
	ALOGI("%s: no num video buffers specified", __FUNCTION__);
	} else {
	ret.numVideoBuffers =
	numVideoBuf->UnsignedAttribute("count", /Default/kDefaultNumVideoBuffer);
	}

	XMLElement *numStillBuf = deviceCfg->FirstChildElement("NumStillBuffers");
	if (numStillBuf == nullptr) {
	ALOGI("%s: no num still buffers specified", __FUNCTION__);
	} else {
	ret.numStillBuffers =
	numStillBuf->UnsignedAttribute("count", /Default/kDefaultNumStillBuffer);
	}

	XMLElement *fpsList = deviceCfg->FirstChildElement("FpsList");
	if (fpsList == nullptr) {
	ALOGI("%s: no fps list specified", __FUNCTION__);
	} else {
	std::vector<FpsLimitation> limits;
	XMLElement *row = fpsList->FirstChildElement("Limit");
	while (row != nullptr) {
	FpsLimitation prevLimit {{0, 0}, 1000.0};
	FpsLimitation limit;
	limit.size = {
	row->UnsignedAttribute("width", /Default/0),
	row->UnsignedAttribute("height", /Default/0)};
	limit.fpsUpperBound = row->DoubleAttribute("fpsBound", /Default/1000.0);
	if (limit.size.width <= prevLimit.size.width \|\|
	limit.size.height <= prevLimit.size.height \|\|
	limit.fpsUpperBound >= prevLimit.fpsUpperBound) {
	ALOGE("%s: FPS limit list must have increasing size and decreasing fps!"
	" Prev %dx%d@%f, Current %dx%d@%f", __FUNCTION__,
	prevLimit.size.width, prevLimit.size.height, prevLimit.fpsUpperBound,
	limit.size.width, limit.size.height, limit.fpsUpperBound);
	return ret;
	}
	limits.push_back(limit);
	row = row->NextSiblingElement("Limit");
	}
	ret.fpsLimits = limits;
	}

	ALOGI("%s: external camera cfg loaded: maxJpgBufSize %d,"
	" num video buffers %d, num still buffers %d",
	__FUNCTION__, ret.maxJpegBufSize,
	ret.numVideoBuffers, ret.numStillBuffers);
	for (const auto& limit : ret.fpsLimits) {
	ALOGI("%s: fpsLimitList: %dx%d@%f", __FUNCTION__,
	limit.size.width, limit.size.height, limit.fpsUpperBound);
	}
	return ret;
	}

	ExternalCameraConfig::ExternalCameraConfig() :
	maxJpegBufSize(kDefaultJpegBufSize),
	numVideoBuffers(kDefaultNumVideoBuffer),
	numStillBuffers(kDefaultNumStillBuffer) {
	fpsLimits.push_back({/Size/{ 640, 480}, /FPS upper bound/30.0});
	fpsLimits.push_back({/Size/{1280, 720}, /FPS upper bound/7.5});
	fpsLimits.push_back({/Size/{1920, 1080}, /FPS upper bound/5.0});
	}


	} // namespace common
	} // namespace external
	} // namespace camera
	} // namespace hardware
	} // namespace android