services/inputflinger/reader/TouchVideoDevice.cpp - LeafOS-Project/android_frameworks_native - 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.
  */

 #include "TouchVideoDevice.h"

 #define LOG_TAG "TouchVideoDevice"

 #include <errno.h>
 #include <fcntl.h>
 #include <inttypes.h>
 #include <linux/videodev2.h>
 #include <sys/ioctl.h>
 #include <sys/mman.h>
 #include <unistd.h>
 #include <iostream>

 #include <android-base/stringprintf.h>
 #include <android-base/unique_fd.h>
 #include <log/log.h>

 using android::base::StringPrintf;
 using android::base::unique_fd;

 namespace android {

 TouchVideoDevice::TouchVideoDevice(int fd, std::string&& name, std::string&& devicePath,
                                    uint32_t height, uint32_t width,
                                    const std::array<const int16_t*, NUM_BUFFERS>& readLocations)
       : mFd(fd),
         mName(std::move(name)),
         mPath(std::move(devicePath)),
         mHeight(height),
         mWidth(width),
         mReadLocations(readLocations) {
     mFrames.reserve(MAX_QUEUE_SIZE);
 };

 std::unique_ptr<TouchVideoDevice> TouchVideoDevice::create(std::string devicePath) {
     unique_fd fd(open(devicePath.c_str(), O_RDWR | O_NONBLOCK | O_CLOEXEC));
     if (fd.get() == INVALID_FD) {
         ALOGE("Could not open video device %s: %s", devicePath.c_str(), strerror(errno));
         return nullptr;
     }

     struct v4l2_capability cap;
     int result = ioctl(fd.get(), VIDIOC_QUERYCAP, &cap);
     if (result == -1) {
         ALOGE("VIDIOC_QUERYCAP failed: %s", strerror(errno));
         return nullptr;
     }
     if (!(cap.capabilities & V4L2_CAP_TOUCH)) {
         ALOGE("Capability V4L2_CAP_TOUCH is not present, can't use device for heatmap data. "
               "Make sure device specifies V4L2_CAP_TOUCH");
         return nullptr;
     }
     ALOGI("Opening video device: driver = %s, card = %s, bus_info = %s, version = %i", cap.driver,
           cap.card, cap.bus_info, cap.version);
     std::string name = reinterpret_cast<const char*>(cap.card);

     struct v4l2_input v4l2_input_struct;
     v4l2_input_struct.index = 0;
     result = ioctl(fd.get(), VIDIOC_ENUMINPUT, &v4l2_input_struct);
     if (result == -1) {
         ALOGE("VIDIOC_ENUMINPUT failed: %s", strerror(errno));
         return nullptr;
     }

     if (v4l2_input_struct.type != V4L2_INPUT_TYPE_TOUCH) {
         ALOGE("Video device does not provide touch data. "
               "Make sure device specifies V4L2_INPUT_TYPE_TOUCH.");
         return nullptr;
     }

     struct v4l2_format v4l2_fmt;
     v4l2_fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     result = ioctl(fd.get(), VIDIOC_G_FMT, &v4l2_fmt);
     if (result == -1) {
         ALOGE("VIDIOC_G_FMT failed: %s", strerror(errno));
         return nullptr;
     }
     const uint32_t height = v4l2_fmt.fmt.pix.height;
     const uint32_t width = v4l2_fmt.fmt.pix.width;
     ALOGI("Frame dimensions: height = %" PRIu32 " width = %" PRIu32, height, width);

     struct v4l2_requestbuffers req = {};
     req.count = NUM_BUFFERS;
     req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     req.memory = V4L2_MEMORY_MMAP;
     // req.reserved is zeroed during initialization, which is required per v4l docs
     result = ioctl(fd.get(), VIDIOC_REQBUFS, &req);
     if (result == -1) {
         ALOGE("VIDIOC_REQBUFS failed: %s", strerror(errno));
         return nullptr;
     }
     if (req.count != NUM_BUFFERS) {
         ALOGE("Requested %zu buffers, but driver responded with count=%i", NUM_BUFFERS, req.count);
         return nullptr;
     }

     struct v4l2_buffer buf = {};
     buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     buf.memory = V4L2_MEMORY_MMAP;
     // buf.reserved and buf.reserved2 are zeroed during initialization, required per v4l docs
     std::array<const int16_t*, NUM_BUFFERS> readLocations;
     for (size_t i = 0; i < NUM_BUFFERS; i++) {
         buf.index = i;
         result = ioctl(fd.get(), VIDIOC_QUERYBUF, &buf);
         if (result == -1) {
             ALOGE("VIDIOC_QUERYBUF failed: %s", strerror(errno));
             return nullptr;
         }
         if (buf.length != height * width * sizeof(int16_t)) {
             ALOGE("Unexpected value of buf.length = %i (offset = %" PRIu32 ")", buf.length,
                   buf.m.offset);
             return nullptr;
         }

         readLocations[i] = static_cast<const int16_t*>(
                 mmap(nullptr /* start anywhere */, buf.length, PROT_READ /* required */,
                      MAP_SHARED /* recommended */, fd.get(), buf.m.offset));
         if (readLocations[i] == MAP_FAILED) {
             ALOGE("%s: map failed: %s", __func__, strerror(errno));
             return nullptr;
         }
     }

     enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     result = ioctl(fd.get(), VIDIOC_STREAMON, &type);
     if (result == -1) {
         ALOGE("VIDIOC_STREAMON failed: %s", strerror(errno));
         return nullptr;
     }

     for (size_t i = 0; i < NUM_BUFFERS; i++) {
         buf.index = i;
         result = ioctl(fd.get(), VIDIOC_QBUF, &buf);
         if (result == -1) {
             ALOGE("VIDIOC_QBUF failed for buffer %zu: %s", i, strerror(errno));
             return nullptr;
         }
     }
     // Using 'new' to access a non-public constructor.
     return std::unique_ptr<TouchVideoDevice>(new TouchVideoDevice(fd.release(), std::move(name),
                                                                   std::move(devicePath), height,
                                                                   width, readLocations));
 }

 size_t TouchVideoDevice::readAndQueueFrames() {
     std::vector<TouchVideoFrame> frames = readFrames();
     const size_t numFrames = frames.size();
     if (numFrames == 0) {
         // Likely an error occurred
         return 0;
     }
     // Concatenate the vectors, then clip up to maximum size allowed
     mFrames.insert(mFrames.end(), std::make_move_iterator(frames.begin()),
                    std::make_move_iterator(frames.end()));
     if (mFrames.size() > MAX_QUEUE_SIZE) {
         // A user-space grip suppression process may be processing the video frames, and holding
         // back the input events. This could result in video frames being produced without the
         // matching input events. Drop the oldest frame here to prepare for the next input event.
         mFrames.erase(mFrames.begin(), mFrames.end() - MAX_QUEUE_SIZE);
     }
     return numFrames;
 }

 std::vector<TouchVideoFrame> TouchVideoDevice::consumeFrames() {
     std::vector<TouchVideoFrame> frames = std::move(mFrames);
     mFrames = {};
     return frames;
 }

 std::optional<TouchVideoFrame> TouchVideoDevice::readFrame() {
     struct v4l2_buffer buf = {};
     buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     buf.memory = V4L2_MEMORY_MMAP;
     int result = ioctl(mFd.get(), VIDIOC_DQBUF, &buf);
     if (result == -1) {
         // EAGAIN means we've reached the end of the read buffer, so it's expected.
         if (errno != EAGAIN) {
             ALOGE("VIDIOC_DQBUF failed: %s", strerror(errno));
         }
         return std::nullopt;
     }
     if ((buf.flags & V4L2_BUF_FLAG_TIMESTAMP_MASK) != V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC) {
         // We use CLOCK_MONOTONIC for input events, so if the clocks don't match,
         // we can't compare timestamps. Just log a warning, since this is a driver issue
         ALOGW("The timestamp %lld.%lld was not acquired using CLOCK_MONOTONIC",
               static_cast<long long>(buf.timestamp.tv_sec),
               static_cast<long long>(buf.timestamp.tv_usec));
     }
     std::vector<int16_t> data(mHeight * mWidth);
     const int16_t* readFrom = mReadLocations[buf.index];
     std::copy(readFrom, readFrom + mHeight * mWidth, data.begin());
     TouchVideoFrame frame(mHeight, mWidth, std::move(data), buf.timestamp);

     result = ioctl(mFd.get(), VIDIOC_QBUF, &buf);
     if (result == -1) {
         ALOGE("VIDIOC_QBUF failed: %s", strerror(errno));
     }
     return std::make_optional(std::move(frame));
 }

 /*
  * This function should not be called unless buffer is ready! This must be checked with
  * select, poll, epoll, or some other similar api first.
  * The oldest frame will be at the beginning of the array.
  */
 std::vector<TouchVideoFrame> TouchVideoDevice::readFrames() {
     std::vector<TouchVideoFrame> frames;
     while (true) {
         std::optional<TouchVideoFrame> frame = readFrame();
         if (!frame) {
             break;
         }
         frames.push_back(std::move(*frame));
     }
     return frames;
 }

 TouchVideoDevice::~TouchVideoDevice() {
     enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     int result = ioctl(mFd.get(), VIDIOC_STREAMOFF, &type);
     if (result == -1) {
         ALOGE("VIDIOC_STREAMOFF failed: %s", strerror(errno));
     }
     for (const int16_t* buffer : mReadLocations) {
         void* bufferAddress = static_cast<void*>(const_cast<int16_t*>(buffer));
         result = munmap(bufferAddress, mHeight * mWidth * sizeof(int16_t));
         if (result == -1) {
             ALOGE("%s: Couldn't unmap: [%s]", __func__, strerror(errno));
         }
     }
 }

 std::string TouchVideoDevice::dump() const {
     return StringPrintf("Video device %s (%s) : height=%" PRIu32 ", width=%" PRIu32
                         ", fd=%i, hasValidFd=%s",
                         mName.c_str(), mPath.c_str(), mHeight, mWidth, mFd.get(),
                         hasValidFd() ? "true" : "false");
 }

 } // 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.
	*/

	#include "TouchVideoDevice.h"

	#define LOG_TAG "TouchVideoDevice"

	#include <errno.h>
	#include <fcntl.h>
	#include <inttypes.h>
	#include <linux/videodev2.h>
	#include <sys/ioctl.h>
	#include <sys/mman.h>
	#include <unistd.h>
	#include <iostream>

	#include <android-base/stringprintf.h>
	#include <android-base/unique_fd.h>
	#include <log/log.h>

	using android::base::StringPrintf;
	using android::base::unique_fd;

	namespace android {

	TouchVideoDevice::TouchVideoDevice(int fd, std::string&& name, std::string&& devicePath,
	uint32_t height, uint32_t width,
	const std::array<const int16_t*, NUM_BUFFERS>& readLocations)
	: mFd(fd),
	mName(std::move(name)),
	mPath(std::move(devicePath)),
	mHeight(height),
	mWidth(width),
	mReadLocations(readLocations) {
	mFrames.reserve(MAX_QUEUE_SIZE);
	};

	std::unique_ptr<TouchVideoDevice> TouchVideoDevice::create(std::string devicePath) {
	unique_fd fd(open(devicePath.c_str(), O_RDWR \| O_NONBLOCK \| O_CLOEXEC));
	if (fd.get() == INVALID_FD) {
	ALOGE("Could not open video device %s: %s", devicePath.c_str(), strerror(errno));
	return nullptr;
	}

	struct v4l2_capability cap;
	int result = ioctl(fd.get(), VIDIOC_QUERYCAP, &cap);
	if (result == -1) {
	ALOGE("VIDIOC_QUERYCAP failed: %s", strerror(errno));
	return nullptr;
	}
	if (!(cap.capabilities & V4L2_CAP_TOUCH)) {
	ALOGE("Capability V4L2_CAP_TOUCH is not present, can't use device for heatmap data. "
	"Make sure device specifies V4L2_CAP_TOUCH");
	return nullptr;
	}
	ALOGI("Opening video device: driver = %s, card = %s, bus_info = %s, version = %i", cap.driver,
	cap.card, cap.bus_info, cap.version);
	std::string name = reinterpret_cast<const char*>(cap.card);

	struct v4l2_input v4l2_input_struct;
	v4l2_input_struct.index = 0;
	result = ioctl(fd.get(), VIDIOC_ENUMINPUT, &v4l2_input_struct);
	if (result == -1) {
	ALOGE("VIDIOC_ENUMINPUT failed: %s", strerror(errno));
	return nullptr;
	}

	if (v4l2_input_struct.type != V4L2_INPUT_TYPE_TOUCH) {
	ALOGE("Video device does not provide touch data. "
	"Make sure device specifies V4L2_INPUT_TYPE_TOUCH.");
	return nullptr;
	}

	struct v4l2_format v4l2_fmt;
	v4l2_fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
	result = ioctl(fd.get(), VIDIOC_G_FMT, &v4l2_fmt);
	if (result == -1) {
	ALOGE("VIDIOC_G_FMT failed: %s", strerror(errno));
	return nullptr;
	}
	const uint32_t height = v4l2_fmt.fmt.pix.height;
	const uint32_t width = v4l2_fmt.fmt.pix.width;
	ALOGI("Frame dimensions: height = %" PRIu32 " width = %" PRIu32, height, width);

	struct v4l2_requestbuffers req = {};
	req.count = NUM_BUFFERS;
	req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
	req.memory = V4L2_MEMORY_MMAP;
	// req.reserved is zeroed during initialization, which is required per v4l docs
	result = ioctl(fd.get(), VIDIOC_REQBUFS, &req);
	if (result == -1) {
	ALOGE("VIDIOC_REQBUFS failed: %s", strerror(errno));
	return nullptr;
	}
	if (req.count != NUM_BUFFERS) {
	ALOGE("Requested %zu buffers, but driver responded with count=%i", NUM_BUFFERS, req.count);
	return nullptr;
	}

	struct v4l2_buffer buf = {};
	buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
	buf.memory = V4L2_MEMORY_MMAP;
	// buf.reserved and buf.reserved2 are zeroed during initialization, required per v4l docs
	std::array<const int16_t*, NUM_BUFFERS> readLocations;
	for (size_t i = 0; i < NUM_BUFFERS; i++) {
	buf.index = i;
	result = ioctl(fd.get(), VIDIOC_QUERYBUF, &buf);
	if (result == -1) {
	ALOGE("VIDIOC_QUERYBUF failed: %s", strerror(errno));
	return nullptr;
	}
	if (buf.length != height * width * sizeof(int16_t)) {
	ALOGE("Unexpected value of buf.length = %i (offset = %" PRIu32 ")", buf.length,
	buf.m.offset);
	return nullptr;
	}

	readLocations[i] = static_cast<const int16_t*>(
	mmap(nullptr /* start anywhere /, buf.length, PROT_READ / required */,
	MAP_SHARED /* recommended */, fd.get(), buf.m.offset));
	if (readLocations[i] == MAP_FAILED) {
	ALOGE("%s: map failed: %s", __func__, strerror(errno));
	return nullptr;
	}
	}

	enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
	result = ioctl(fd.get(), VIDIOC_STREAMON, &type);
	if (result == -1) {
	ALOGE("VIDIOC_STREAMON failed: %s", strerror(errno));
	return nullptr;
	}

	for (size_t i = 0; i < NUM_BUFFERS; i++) {
	buf.index = i;
	result = ioctl(fd.get(), VIDIOC_QBUF, &buf);
	if (result == -1) {
	ALOGE("VIDIOC_QBUF failed for buffer %zu: %s", i, strerror(errno));
	return nullptr;
	}
	}
	// Using 'new' to access a non-public constructor.
	return std::unique_ptr<TouchVideoDevice>(new TouchVideoDevice(fd.release(), std::move(name),
	std::move(devicePath), height,
	width, readLocations));
	}

	size_t TouchVideoDevice::readAndQueueFrames() {
	std::vector<TouchVideoFrame> frames = readFrames();
	const size_t numFrames = frames.size();
	if (numFrames == 0) {
	// Likely an error occurred
	return 0;
	}
	// Concatenate the vectors, then clip up to maximum size allowed
	mFrames.insert(mFrames.end(), std::make_move_iterator(frames.begin()),
	std::make_move_iterator(frames.end()));
	if (mFrames.size() > MAX_QUEUE_SIZE) {
	// A user-space grip suppression process may be processing the video frames, and holding
	// back the input events. This could result in video frames being produced without the
	// matching input events. Drop the oldest frame here to prepare for the next input event.
	mFrames.erase(mFrames.begin(), mFrames.end() - MAX_QUEUE_SIZE);
	}
	return numFrames;
	}

	std::vector<TouchVideoFrame> TouchVideoDevice::consumeFrames() {
	std::vector<TouchVideoFrame> frames = std::move(mFrames);
	mFrames = {};
	return frames;
	}

	std::optional<TouchVideoFrame> TouchVideoDevice::readFrame() {
	struct v4l2_buffer buf = {};
	buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
	buf.memory = V4L2_MEMORY_MMAP;
	int result = ioctl(mFd.get(), VIDIOC_DQBUF, &buf);
	if (result == -1) {
	// EAGAIN means we've reached the end of the read buffer, so it's expected.
	if (errno != EAGAIN) {
	ALOGE("VIDIOC_DQBUF failed: %s", strerror(errno));
	}
	return std::nullopt;
	}
	if ((buf.flags & V4L2_BUF_FLAG_TIMESTAMP_MASK) != V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC) {
	// We use CLOCK_MONOTONIC for input events, so if the clocks don't match,
	// we can't compare timestamps. Just log a warning, since this is a driver issue
	ALOGW("The timestamp %lld.%lld was not acquired using CLOCK_MONOTONIC",
	static_cast<long long>(buf.timestamp.tv_sec),
	static_cast<long long>(buf.timestamp.tv_usec));
	}
	std::vector<int16_t> data(mHeight * mWidth);
	const int16_t* readFrom = mReadLocations[buf.index];
	std::copy(readFrom, readFrom + mHeight * mWidth, data.begin());
	TouchVideoFrame frame(mHeight, mWidth, std::move(data), buf.timestamp);

	result = ioctl(mFd.get(), VIDIOC_QBUF, &buf);
	if (result == -1) {
	ALOGE("VIDIOC_QBUF failed: %s", strerror(errno));
	}
	return std::make_optional(std::move(frame));
	}

	/*
	* This function should not be called unless buffer is ready! This must be checked with
	* select, poll, epoll, or some other similar api first.
	* The oldest frame will be at the beginning of the array.
	*/
	std::vector<TouchVideoFrame> TouchVideoDevice::readFrames() {
	std::vector<TouchVideoFrame> frames;
	while (true) {
	std::optional<TouchVideoFrame> frame = readFrame();
	if (!frame) {
	break;
	}
	frames.push_back(std::move(*frame));
	}
	return frames;
	}

	TouchVideoDevice::~TouchVideoDevice() {
	enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
	int result = ioctl(mFd.get(), VIDIOC_STREAMOFF, &type);
	if (result == -1) {
	ALOGE("VIDIOC_STREAMOFF failed: %s", strerror(errno));
	}
	for (const int16_t* buffer : mReadLocations) {
	void* bufferAddress = static_cast<void>(const_cast<int16_t>(buffer));
	result = munmap(bufferAddress, mHeight * mWidth * sizeof(int16_t));
	if (result == -1) {
	ALOGE("%s: Couldn't unmap: [%s]", __func__, strerror(errno));
	}
	}
	}

	std::string TouchVideoDevice::dump() const {
	return StringPrintf("Video device %s (%s) : height=%" PRIu32 ", width=%" PRIu32
	", fd=%i, hasValidFd=%s",
	mName.c_str(), mPath.c_str(), mHeight, mWidth, mFd.get(),
	hasValidFd() ? "true" : "false");
	}

	} // namespace android