| /* |
| * 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)); |
| 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) { |
| ALOGE("More than %zu frames have been accumulated. Dropping %zu frames", MAX_QUEUE_SIZE, |
| mFrames.size() - MAX_QUEUE_SIZE); |
| 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 %ld.%ld was not acquired using CLOCK_MONOTONIC", |
| buf.timestamp.tv_sec, 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 |