modules/camera/3_4/v4l2_wrapper.cpp - platform/hardware/libhardware - Git at Google

 /*
  * Copyright 2016 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 "v4l2_wrapper.h"

 #include <algorithm>
 #include <array>
 #include <limits>
 #include <mutex>
 #include <vector>

 #include <fcntl.h>
 #include <linux/videodev2.h>
 #include <sys/stat.h>
 #include <sys/types.h>

 #include <android-base/unique_fd.h>

 #include "common.h"
 #include "stream_format.h"
 #include "v4l2_gralloc.h"

 namespace v4l2_camera_hal {

 const int32_t kStandardSizes[][2] = {{640, 480}, {320, 240}};

 V4L2Wrapper* V4L2Wrapper::NewV4L2Wrapper(const std::string device_path) {
   std::unique_ptr<V4L2Gralloc> gralloc(V4L2Gralloc::NewV4L2Gralloc());
   if (!gralloc) {
     HAL_LOGE("Failed to initialize gralloc helper.");
     return nullptr;
   }

   return new V4L2Wrapper(device_path, std::move(gralloc));
 }

 V4L2Wrapper::V4L2Wrapper(const std::string device_path,
                          std::unique_ptr<V4L2Gralloc> gralloc)
     : device_path_(std::move(device_path)),
       gralloc_(std::move(gralloc)),
       connection_count_(0) {}

 V4L2Wrapper::~V4L2Wrapper() {}

 int V4L2Wrapper::Connect() {
   HAL_LOG_ENTER();
   std::lock_guard<std::mutex> lock(connection_lock_);

   if (connected()) {
     HAL_LOGV("Camera device %s is already connected.", device_path_.c_str());
     ++connection_count_;
     return 0;
   }

   // Open in nonblocking mode (DQBUF may return EAGAIN).
   int fd = TEMP_FAILURE_RETRY(open(device_path_.c_str(), O_RDWR | O_NONBLOCK));
   if (fd < 0) {
     HAL_LOGE("failed to open %s (%s)", device_path_.c_str(), strerror(errno));
     return -ENODEV;
   }
   device_fd_.reset(fd);
   ++connection_count_;

   // Check if this connection has the extended control query capability.
   v4l2_query_ext_ctrl query;
   query.id = V4L2_CTRL_FLAG_NEXT_CTRL | V4L2_CTRL_FLAG_NEXT_COMPOUND;
   extended_query_supported_ = (IoctlLocked(VIDIOC_QUERY_EXT_CTRL, &query) == 0);

   // TODO(b/29185945): confirm this is a supported device.
   // This is checked by the HAL, but the device at device_path_ may
   // not be the same one that was there when the HAL was loaded.
   // (Alternatively, better hotplugging support may make this unecessary
   // by disabling cameras that get disconnected and checking newly connected
   // cameras, so Connect() is never called on an unsupported camera)
   return 0;
 }

 void V4L2Wrapper::Disconnect() {
   HAL_LOG_ENTER();
   std::lock_guard<std::mutex> lock(connection_lock_);

   if (connection_count_ == 0) {
     // Not connected.
     HAL_LOGE("Camera device %s is not connected, cannot disconnect.",
              device_path_.c_str());
     return;
   }

   --connection_count_;
   if (connection_count_ > 0) {
     HAL_LOGV("Disconnected from camera device %s. %d connections remain.",
              device_path_.c_str());
     return;
   }

   device_fd_.reset(-1);  // Includes close().
   format_.reset();
   buffers_.clear();
   // Closing the device releases all queued buffers back to the user.
   gralloc_->unlockAllBuffers();
 }

 // Helper function. Should be used instead of ioctl throughout this class.
 template <typename T>
 int V4L2Wrapper::IoctlLocked(int request, T data) {
   // Potentially called so many times logging entry is a bad idea.
   std::lock_guard<std::mutex> lock(device_lock_);

   if (!connected()) {
     HAL_LOGE("Device %s not connected.", device_path_.c_str());
     return -ENODEV;
   }
   return TEMP_FAILURE_RETRY(ioctl(device_fd_.get(), request, data));
 }

 int V4L2Wrapper::StreamOn() {
   if (!format_) {
     HAL_LOGE("Stream format must be set before turning on stream.");
     return -EINVAL;
   }

   int32_t type = format_->type();
   if (IoctlLocked(VIDIOC_STREAMON, &type) < 0) {
     HAL_LOGE("STREAMON fails: %s", strerror(errno));
     return -ENODEV;
   }

   HAL_LOGV("Stream turned on.");
   return 0;
 }

 int V4L2Wrapper::StreamOff() {
   if (!format_) {
     // Can't have turned on the stream without format being set,
     // so nothing to turn off here.
     return 0;
   }

   int32_t type = format_->type();
   int res = IoctlLocked(VIDIOC_STREAMOFF, &type);
   // Calling STREAMOFF releases all queued buffers back to the user.
   int gralloc_res = gralloc_->unlockAllBuffers();
   // No buffers in flight.
   for (size_t i = 0; i < buffers_.size(); ++i) {
     buffers_[i] = false;
   }
   if (res < 0) {
     HAL_LOGE("STREAMOFF fails: %s", strerror(errno));
     return -ENODEV;
   }
   if (gralloc_res < 0) {
     HAL_LOGE("Failed to unlock all buffers after turning stream off.");
     return gralloc_res;
   }

   HAL_LOGV("Stream turned off.");
   return 0;
 }

 int V4L2Wrapper::QueryControl(uint32_t control_id,
                               v4l2_query_ext_ctrl* result) {
   int res;

   memset(result, 0, sizeof(*result));

   if (extended_query_supported_) {
     result->id = control_id;
     res = IoctlLocked(VIDIOC_QUERY_EXT_CTRL, result);
     // Assuming the operation was supported (not ENOTTY), no more to do.
     if (errno != ENOTTY) {
       if (res) {
         HAL_LOGE("QUERY_EXT_CTRL fails: %s", strerror(errno));
         return -ENODEV;
       }
       return 0;
     }
   }

   // Extended control querying not supported, fall back to basic control query.
   v4l2_queryctrl query;
   query.id = control_id;
   if (IoctlLocked(VIDIOC_QUERYCTRL, &query)) {
     HAL_LOGE("QUERYCTRL fails: %s", strerror(errno));
     return -ENODEV;
   }

   // Convert the basic result to the extended result.
   result->id = query.id;
   result->type = query.type;
   memcpy(result->name, query.name, sizeof(query.name));
   result->minimum = query.minimum;
   if (query.type == V4L2_CTRL_TYPE_BITMASK) {
     // According to the V4L2 documentation, when type is BITMASK,
     // max and default should be interpreted as __u32. Practically,
     // this means the conversion from 32 bit to 64 will pad with 0s not 1s.
     result->maximum = static_cast<uint32_t>(query.maximum);
     result->default_value = static_cast<uint32_t>(query.default_value);
   } else {
     result->maximum = query.maximum;
     result->default_value = query.default_value;
   }
   result->step = static_cast<uint32_t>(query.step);
   result->flags = query.flags;
   result->elems = 1;
   switch (result->type) {
     case V4L2_CTRL_TYPE_INTEGER64:
       result->elem_size = sizeof(int64_t);
       break;
     case V4L2_CTRL_TYPE_STRING:
       result->elem_size = result->maximum + 1;
       break;
     default:
       result->elem_size = sizeof(int32_t);
       break;
   }

   return 0;
 }

 int V4L2Wrapper::GetControl(uint32_t control_id, int32_t* value) {
   // For extended controls (any control class other than "user"),
   // G_EXT_CTRL must be used instead of G_CTRL.
   if (V4L2_CTRL_ID2CLASS(control_id) != V4L2_CTRL_CLASS_USER) {
     v4l2_ext_control control;
     v4l2_ext_controls controls;
     memset(&control, 0, sizeof(control));
     memset(&controls, 0, sizeof(controls));

     control.id = control_id;
     controls.ctrl_class = V4L2_CTRL_ID2CLASS(control_id);
     controls.count = 1;
     controls.controls = &control;

     if (IoctlLocked(VIDIOC_G_EXT_CTRLS, &controls) < 0) {
       HAL_LOGE("G_EXT_CTRLS fails: %s", strerror(errno));
       return -ENODEV;
     }
     *value = control.value;
   } else {
     v4l2_control control{control_id, 0};
     if (IoctlLocked(VIDIOC_G_CTRL, &control) < 0) {
       HAL_LOGE("G_CTRL fails: %s", strerror(errno));
       return -ENODEV;
     }
     *value = control.value;
   }
   return 0;
 }

 int V4L2Wrapper::SetControl(uint32_t control_id,
                             int32_t desired,
                             int32_t* result) {
   int32_t result_value = 0;

   // TODO(b/29334616): When async, this may need to check if the stream
   // is on, and if so, lock it off while setting format. Need to look
   // into if V4L2 supports adjusting controls while the stream is on.

   // For extended controls (any control class other than "user"),
   // S_EXT_CTRL must be used instead of S_CTRL.
   if (V4L2_CTRL_ID2CLASS(control_id) != V4L2_CTRL_CLASS_USER) {
     v4l2_ext_control control;
     v4l2_ext_controls controls;
     memset(&control, 0, sizeof(control));
     memset(&controls, 0, sizeof(controls));

     control.id = control_id;
     control.value = desired;
     controls.ctrl_class = V4L2_CTRL_ID2CLASS(control_id);
     controls.count = 1;
     controls.controls = &control;

     if (IoctlLocked(VIDIOC_S_EXT_CTRLS, &controls) < 0) {
       HAL_LOGE("S_EXT_CTRLS fails: %s", strerror(errno));
       return -ENODEV;
     }
     result_value = control.value;
   } else {
     v4l2_control control{control_id, desired};
     if (IoctlLocked(VIDIOC_S_CTRL, &control) < 0) {
       HAL_LOGE("S_CTRL fails: %s", strerror(errno));
       return -ENODEV;
     }
     result_value = control.value;
   }

   // If the caller wants to know the result, pass it back.
   if (result != nullptr) {
     *result = result_value;
   }
   return 0;
 }

 int V4L2Wrapper::GetFormats(std::set<uint32_t>* v4l2_formats) {
   HAL_LOG_ENTER();

   v4l2_fmtdesc format_query;
   memset(&format_query, 0, sizeof(format_query));
   // TODO(b/30000211): multiplanar support.
   format_query.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
   while (IoctlLocked(VIDIOC_ENUM_FMT, &format_query) >= 0) {
     v4l2_formats->insert(format_query.pixelformat);
     ++format_query.index;
   }

   if (errno != EINVAL) {
     HAL_LOGE(
         "ENUM_FMT fails at index %d: %s", format_query.index, strerror(errno));
     return -ENODEV;
   }
   return 0;
 }

 int V4L2Wrapper::GetFormatFrameSizes(uint32_t v4l2_format,
                                      std::set<std::array<int32_t, 2>>* sizes) {
   v4l2_frmsizeenum size_query;
   memset(&size_query, 0, sizeof(size_query));
   size_query.pixel_format = v4l2_format;
   if (IoctlLocked(VIDIOC_ENUM_FRAMESIZES, &size_query) < 0) {
     HAL_LOGE("ENUM_FRAMESIZES failed: %s", strerror(errno));
     return -ENODEV;
   }
   if (size_query.type == V4L2_FRMSIZE_TYPE_DISCRETE) {
     // Discrete: enumerate all sizes using VIDIOC_ENUM_FRAMESIZES.
     // Assuming that a driver with discrete frame sizes has a reasonable number
     // of them.
     do {
       sizes->insert({{{static_cast<int32_t>(size_query.discrete.width),
                        static_cast<int32_t>(size_query.discrete.height)}}});
       ++size_query.index;
     } while (IoctlLocked(VIDIOC_ENUM_FRAMESIZES, &size_query) >= 0);
     if (errno != EINVAL) {
       HAL_LOGE("ENUM_FRAMESIZES fails at index %d: %s",
                size_query.index,
                strerror(errno));
       return -ENODEV;
     }
   } else {
     // Continuous/Step-wise: based on the stepwise struct returned by the query.
     // Fully listing all possible sizes, with large enough range/small enough
     // step size, may produce far too many potential sizes. Instead, find the
     // closest to a set of standard sizes.
     for (const auto size : kStandardSizes) {
       // Find the closest size, rounding up.
       uint32_t desired_width = size[0];
       uint32_t desired_height = size[1];
       if (desired_width < size_query.stepwise.min_width ||
           desired_height < size_query.stepwise.min_height) {
         HAL_LOGV("Standard size %u x %u is too small for format %d",
                  desired_width,
                  desired_height,
                  v4l2_format);
         continue;
       } else if (desired_width > size_query.stepwise.max_width &&
                  desired_height > size_query.stepwise.max_height) {
         HAL_LOGV("Standard size %u x %u is too big for format %d",
                  desired_width,
                  desired_height,
                  v4l2_format);
         continue;
       }

       // Round up.
       uint32_t width_steps = (desired_width - size_query.stepwise.min_width +
                               size_query.stepwise.step_width - 1) /
                              size_query.stepwise.step_width;
       uint32_t height_steps = (desired_height - size_query.stepwise.min_height +
                                size_query.stepwise.step_height - 1) /
                               size_query.stepwise.step_height;
       sizes->insert(
           {{{static_cast<int32_t>(size_query.stepwise.min_width +
                                   width_steps * size_query.stepwise.step_width),
              static_cast<int32_t>(size_query.stepwise.min_height +
                                   height_steps *
                                       size_query.stepwise.step_height)}}});
     }
   }
   return 0;
 }

 // Converts a v4l2_fract with units of seconds to an int64_t with units of ns.
 inline int64_t FractToNs(const v4l2_fract& fract) {
   return (1000000000LL * fract.numerator) / fract.denominator;
 }

 int V4L2Wrapper::GetFormatFrameDurationRange(
     uint32_t v4l2_format,
     const std::array<int32_t, 2>& size,
     std::array<int64_t, 2>* duration_range) {
   // Potentially called so many times logging entry is a bad idea.

   v4l2_frmivalenum duration_query;
   memset(&duration_query, 0, sizeof(duration_query));
   duration_query.pixel_format = v4l2_format;
   duration_query.width = size[0];
   duration_query.height = size[1];
   if (IoctlLocked(VIDIOC_ENUM_FRAMEINTERVALS, &duration_query) < 0) {
     HAL_LOGE("ENUM_FRAMEINTERVALS failed: %s", strerror(errno));
     return -ENODEV;
   }

   int64_t min = std::numeric_limits<int64_t>::max();
   int64_t max = std::numeric_limits<int64_t>::min();
   if (duration_query.type == V4L2_FRMSIZE_TYPE_DISCRETE) {
     // Discrete: enumerate all durations using VIDIOC_ENUM_FRAMEINTERVALS.
     do {
       min = std::min(min, FractToNs(duration_query.discrete));
       max = std::max(max, FractToNs(duration_query.discrete));
       ++duration_query.index;
     } while (IoctlLocked(VIDIOC_ENUM_FRAMEINTERVALS, &duration_query) >= 0);
     if (errno != EINVAL) {
       HAL_LOGE("ENUM_FRAMEINTERVALS fails at index %d: %s",
                duration_query.index,
                strerror(errno));
       return -ENODEV;
     }
   } else {
     // Continuous/Step-wise: simply convert the given min and max.
     min = FractToNs(duration_query.stepwise.min);
     max = FractToNs(duration_query.stepwise.max);
   }
   (*duration_range)[0] = min;
   (*duration_range)[1] = max;
   return 0;
 }

 int V4L2Wrapper::SetFormat(const StreamFormat& desired_format,
                            uint32_t* result_max_buffers) {
   HAL_LOG_ENTER();

   if (format_ && desired_format == *format_) {
     HAL_LOGV("Already in correct format, skipping format setting.");
     *result_max_buffers = buffers_.size();
     return 0;
   }

   // Not in the correct format, set the new one.

   if (format_) {
     // If we had an old format, first request 0 buffers to inform the device
     // we're no longer using any previously "allocated" buffers from the old
     // format. This seems like it shouldn't be necessary for USERPTR memory,
     // and/or should happen from turning the stream off, but the driver
     // complained. May be a driver issue, or may be intended behavior.
     int res = RequestBuffers(0);
     if (res) {
       return res;
     }
   }

   // Set the camera to the new format.
   v4l2_format new_format;
   desired_format.FillFormatRequest(&new_format);
   // TODO(b/29334616): When async, this will need to check if the stream
   // is on, and if so, lock it off while setting format.

   if (IoctlLocked(VIDIOC_S_FMT, &new_format) < 0) {
     HAL_LOGE("S_FMT failed: %s", strerror(errno));
     return -ENODEV;
   }

   // Check that the driver actually set to the requested values.
   if (desired_format != new_format) {
     HAL_LOGE("Device doesn't support desired stream configuration.");
     return -EINVAL;
   }

   // Keep track of our new format.
   format_.reset(new StreamFormat(new_format));

   // Format changed, request new buffers.
   int res = RequestBuffers(1);
   if (res) {
     HAL_LOGE("Requesting buffers for new format failed.");
     return res;
   }
   *result_max_buffers = buffers_.size();
   return 0;
 }

 int V4L2Wrapper::RequestBuffers(uint32_t num_requested) {
   v4l2_requestbuffers req_buffers;
   memset(&req_buffers, 0, sizeof(req_buffers));
   req_buffers.type = format_->type();
   req_buffers.memory = V4L2_MEMORY_USERPTR;
   req_buffers.count = num_requested;

   int res = IoctlLocked(VIDIOC_REQBUFS, &req_buffers);
   // Calling REQBUFS releases all queued buffers back to the user.
   int gralloc_res = gralloc_->unlockAllBuffers();
   if (res < 0) {
     HAL_LOGE("REQBUFS failed: %s", strerror(errno));
     return -ENODEV;
   }
   if (gralloc_res < 0) {
     HAL_LOGE("Failed to unlock all buffers when setting up new buffers.");
     return gralloc_res;
   }

   // V4L2 will set req_buffers.count to a number of buffers it can handle.
   if (num_requested > 0 && req_buffers.count < 1) {
     HAL_LOGE("REQBUFS claims it can't handle any buffers.");
     return -ENODEV;
   }
   buffers_.resize(req_buffers.count, false);

   return 0;
 }

 int V4L2Wrapper::EnqueueBuffer(const camera3_stream_buffer_t* camera_buffer,
                                uint32_t* enqueued_index) {
   if (!format_) {
     HAL_LOGE("Stream format must be set before enqueuing buffers.");
     return -ENODEV;
   }

   // Find a free buffer index. Could use some sort of persistent hinting
   // here to improve expected efficiency, but buffers_.size() is expected
   // to be low enough (<10 experimentally) that it's not worth it.
   int index = -1;
   {
     std::lock_guard<std::mutex> guard(buffer_queue_lock_);
     for (int i = 0; i < buffers_.size(); ++i) {
       if (!buffers_[i]) {
         index = i;
         break;
       }
     }
   }
   if (index < 0) {
     // Note: The HAL should be tracking the number of buffers in flight
     // for each stream, and should never overflow the device.
     HAL_LOGE("Cannot enqueue buffer: stream is already full.");
     return -ENODEV;
   }

   // Set up a v4l2 buffer struct.
   v4l2_buffer device_buffer;
   memset(&device_buffer, 0, sizeof(device_buffer));
   device_buffer.type = format_->type();
   device_buffer.index = index;

   // Use QUERYBUF to ensure our buffer/device is in good shape,
   // and fill out remaining fields.
   if (IoctlLocked(VIDIOC_QUERYBUF, &device_buffer) < 0) {
     HAL_LOGE("QUERYBUF fails: %s", strerror(errno));
     return -ENODEV;
   }

   // Lock the buffer for writing (fills in the user pointer field).
   int res =
       gralloc_->lock(camera_buffer, format_->bytes_per_line(), &device_buffer);
   if (res) {
     HAL_LOGE("Gralloc failed to lock buffer.");
     return res;
   }
   if (IoctlLocked(VIDIOC_QBUF, &device_buffer) < 0) {
     HAL_LOGE("QBUF fails: %s", strerror(errno));
     gralloc_->unlock(&device_buffer);
     return -ENODEV;
   }

   // Mark the buffer as in flight.
   std::lock_guard<std::mutex> guard(buffer_queue_lock_);
   buffers_[index] = true;

   if (enqueued_index) {
     *enqueued_index = index;
   }
   return 0;
 }

 int V4L2Wrapper::DequeueBuffer(uint32_t* dequeued_index) {
   if (!format_) {
     HAL_LOGV(
         "Format not set, so stream can't be on, "
         "so no buffers available for dequeueing");
     return -EAGAIN;
   }

   v4l2_buffer buffer;
   memset(&buffer, 0, sizeof(buffer));
   buffer.type = format_->type();
   buffer.memory = V4L2_MEMORY_USERPTR;
   int res = IoctlLocked(VIDIOC_DQBUF, &buffer);
   if (res) {
     if (errno == EAGAIN) {
       // Expected failure.
       return -EAGAIN;
     } else {
       // Unexpected failure.
       HAL_LOGE("DQBUF fails: %s", strerror(errno));
       return -ENODEV;
     }
   }

   // Mark the buffer as no longer in flight.
   {
     std::lock_guard<std::mutex> guard(buffer_queue_lock_);
     buffers_[buffer.index] = false;
   }

   // Now that we're done painting the buffer, we can unlock it.
   res = gralloc_->unlock(&buffer);
   if (res) {
     HAL_LOGE("Gralloc failed to unlock buffer after dequeueing.");
     return res;
   }

   if (dequeued_index) {
     *dequeued_index = buffer.index;
   }
   return 0;
 }

 }  // namespace v4l2_camera_hal
	/*
	* Copyright 2016 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 "v4l2_wrapper.h"

	#include <algorithm>
	#include <array>
	#include <limits>
	#include <mutex>
	#include <vector>

	#include <fcntl.h>
	#include <linux/videodev2.h>
	#include <sys/stat.h>
	#include <sys/types.h>

	#include <android-base/unique_fd.h>

	#include "common.h"
	#include "stream_format.h"
	#include "v4l2_gralloc.h"

	namespace v4l2_camera_hal {

	const int32_t kStandardSizes[][2] = {{640, 480}, {320, 240}};

	V4L2Wrapper* V4L2Wrapper::NewV4L2Wrapper(const std::string device_path) {
	std::unique_ptr<V4L2Gralloc> gralloc(V4L2Gralloc::NewV4L2Gralloc());
	if (!gralloc) {
	HAL_LOGE("Failed to initialize gralloc helper.");
	return nullptr;
	}

	return new V4L2Wrapper(device_path, std::move(gralloc));
	}

	V4L2Wrapper::V4L2Wrapper(const std::string device_path,
	std::unique_ptr<V4L2Gralloc> gralloc)
	: device_path_(std::move(device_path)),
	gralloc_(std::move(gralloc)),
	connection_count_(0) {}

	V4L2Wrapper::~V4L2Wrapper() {}

	int V4L2Wrapper::Connect() {
	HAL_LOG_ENTER();
	std::lock_guard<std::mutex> lock(connection_lock_);

	if (connected()) {
	HAL_LOGV("Camera device %s is already connected.", device_path_.c_str());
	++connection_count_;
	return 0;
	}

	// Open in nonblocking mode (DQBUF may return EAGAIN).
	int fd = TEMP_FAILURE_RETRY(open(device_path_.c_str(), O_RDWR \| O_NONBLOCK));
	if (fd < 0) {
	HAL_LOGE("failed to open %s (%s)", device_path_.c_str(), strerror(errno));
	return -ENODEV;
	}
	device_fd_.reset(fd);
	++connection_count_;

	// Check if this connection has the extended control query capability.
	v4l2_query_ext_ctrl query;
	query.id = V4L2_CTRL_FLAG_NEXT_CTRL \| V4L2_CTRL_FLAG_NEXT_COMPOUND;
	extended_query_supported_ = (IoctlLocked(VIDIOC_QUERY_EXT_CTRL, &query) == 0);

	// TODO(b/29185945): confirm this is a supported device.
	// This is checked by the HAL, but the device at device_path_ may
	// not be the same one that was there when the HAL was loaded.
	// (Alternatively, better hotplugging support may make this unecessary
	// by disabling cameras that get disconnected and checking newly connected
	// cameras, so Connect() is never called on an unsupported camera)
	return 0;
	}

	void V4L2Wrapper::Disconnect() {
	HAL_LOG_ENTER();
	std::lock_guard<std::mutex> lock(connection_lock_);

	if (connection_count_ == 0) {
	// Not connected.
	HAL_LOGE("Camera device %s is not connected, cannot disconnect.",
	device_path_.c_str());
	return;
	}

	--connection_count_;
	if (connection_count_ > 0) {
	HAL_LOGV("Disconnected from camera device %s. %d connections remain.",
	device_path_.c_str());
	return;
	}

	device_fd_.reset(-1); // Includes close().
	format_.reset();
	buffers_.clear();
	// Closing the device releases all queued buffers back to the user.
	gralloc_->unlockAllBuffers();
	}

	// Helper function. Should be used instead of ioctl throughout this class.
	template <typename T>
	int V4L2Wrapper::IoctlLocked(int request, T data) {
	// Potentially called so many times logging entry is a bad idea.
	std::lock_guard<std::mutex> lock(device_lock_);

	if (!connected()) {
	HAL_LOGE("Device %s not connected.", device_path_.c_str());
	return -ENODEV;
	}
	return TEMP_FAILURE_RETRY(ioctl(device_fd_.get(), request, data));
	}

	int V4L2Wrapper::StreamOn() {
	if (!format_) {
	HAL_LOGE("Stream format must be set before turning on stream.");
	return -EINVAL;
	}

	int32_t type = format_->type();
	if (IoctlLocked(VIDIOC_STREAMON, &type) < 0) {
	HAL_LOGE("STREAMON fails: %s", strerror(errno));
	return -ENODEV;
	}

	HAL_LOGV("Stream turned on.");
	return 0;
	}

	int V4L2Wrapper::StreamOff() {
	if (!format_) {
	// Can't have turned on the stream without format being set,
	// so nothing to turn off here.
	return 0;
	}

	int32_t type = format_->type();
	int res = IoctlLocked(VIDIOC_STREAMOFF, &type);
	// Calling STREAMOFF releases all queued buffers back to the user.
	int gralloc_res = gralloc_->unlockAllBuffers();
	// No buffers in flight.
	for (size_t i = 0; i < buffers_.size(); ++i) {
	buffers_[i] = false;
	}
	if (res < 0) {
	HAL_LOGE("STREAMOFF fails: %s", strerror(errno));
	return -ENODEV;
	}
	if (gralloc_res < 0) {
	HAL_LOGE("Failed to unlock all buffers after turning stream off.");
	return gralloc_res;
	}

	HAL_LOGV("Stream turned off.");
	return 0;
	}

	int V4L2Wrapper::QueryControl(uint32_t control_id,
	v4l2_query_ext_ctrl* result) {
	int res;

	memset(result, 0, sizeof(*result));

	if (extended_query_supported_) {
	result->id = control_id;
	res = IoctlLocked(VIDIOC_QUERY_EXT_CTRL, result);
	// Assuming the operation was supported (not ENOTTY), no more to do.
	if (errno != ENOTTY) {
	if (res) {
	HAL_LOGE("QUERY_EXT_CTRL fails: %s", strerror(errno));
	return -ENODEV;
	}
	return 0;
	}
	}

	// Extended control querying not supported, fall back to basic control query.
	v4l2_queryctrl query;
	query.id = control_id;
	if (IoctlLocked(VIDIOC_QUERYCTRL, &query)) {
	HAL_LOGE("QUERYCTRL fails: %s", strerror(errno));
	return -ENODEV;
	}

	// Convert the basic result to the extended result.
	result->id = query.id;
	result->type = query.type;
	memcpy(result->name, query.name, sizeof(query.name));
	result->minimum = query.minimum;
	if (query.type == V4L2_CTRL_TYPE_BITMASK) {
	// According to the V4L2 documentation, when type is BITMASK,
	// max and default should be interpreted as __u32. Practically,
	// this means the conversion from 32 bit to 64 will pad with 0s not 1s.
	result->maximum = static_cast<uint32_t>(query.maximum);
	result->default_value = static_cast<uint32_t>(query.default_value);
	} else {
	result->maximum = query.maximum;
	result->default_value = query.default_value;
	}
	result->step = static_cast<uint32_t>(query.step);
	result->flags = query.flags;
	result->elems = 1;
	switch (result->type) {
	case V4L2_CTRL_TYPE_INTEGER64:
	result->elem_size = sizeof(int64_t);
	break;
	case V4L2_CTRL_TYPE_STRING:
	result->elem_size = result->maximum + 1;
	break;
	default:
	result->elem_size = sizeof(int32_t);
	break;
	}

	return 0;
	}

	int V4L2Wrapper::GetControl(uint32_t control_id, int32_t* value) {
	// For extended controls (any control class other than "user"),
	// G_EXT_CTRL must be used instead of G_CTRL.
	if (V4L2_CTRL_ID2CLASS(control_id) != V4L2_CTRL_CLASS_USER) {
	v4l2_ext_control control;
	v4l2_ext_controls controls;
	memset(&control, 0, sizeof(control));
	memset(&controls, 0, sizeof(controls));

	control.id = control_id;
	controls.ctrl_class = V4L2_CTRL_ID2CLASS(control_id);
	controls.count = 1;
	controls.controls = &control;

	if (IoctlLocked(VIDIOC_G_EXT_CTRLS, &controls) < 0) {
	HAL_LOGE("G_EXT_CTRLS fails: %s", strerror(errno));
	return -ENODEV;
	}
	*value = control.value;
	} else {
	v4l2_control control{control_id, 0};
	if (IoctlLocked(VIDIOC_G_CTRL, &control) < 0) {
	HAL_LOGE("G_CTRL fails: %s", strerror(errno));
	return -ENODEV;
	}
	*value = control.value;
	}
	return 0;
	}

	int V4L2Wrapper::SetControl(uint32_t control_id,
	int32_t desired,
	int32_t* result) {
	int32_t result_value = 0;

	// TODO(b/29334616): When async, this may need to check if the stream
	// is on, and if so, lock it off while setting format. Need to look
	// into if V4L2 supports adjusting controls while the stream is on.

	// For extended controls (any control class other than "user"),
	// S_EXT_CTRL must be used instead of S_CTRL.
	if (V4L2_CTRL_ID2CLASS(control_id) != V4L2_CTRL_CLASS_USER) {
	v4l2_ext_control control;
	v4l2_ext_controls controls;
	memset(&control, 0, sizeof(control));
	memset(&controls, 0, sizeof(controls));

	control.id = control_id;
	control.value = desired;
	controls.ctrl_class = V4L2_CTRL_ID2CLASS(control_id);
	controls.count = 1;
	controls.controls = &control;

	if (IoctlLocked(VIDIOC_S_EXT_CTRLS, &controls) < 0) {
	HAL_LOGE("S_EXT_CTRLS fails: %s", strerror(errno));
	return -ENODEV;
	}
	result_value = control.value;
	} else {
	v4l2_control control{control_id, desired};
	if (IoctlLocked(VIDIOC_S_CTRL, &control) < 0) {
	HAL_LOGE("S_CTRL fails: %s", strerror(errno));
	return -ENODEV;
	}
	result_value = control.value;
	}

	// If the caller wants to know the result, pass it back.
	if (result != nullptr) {
	*result = result_value;
	}
	return 0;
	}

	int V4L2Wrapper::GetFormats(std::set<uint32_t>* v4l2_formats) {
	HAL_LOG_ENTER();

	v4l2_fmtdesc format_query;
	memset(&format_query, 0, sizeof(format_query));
	// TODO(b/30000211): multiplanar support.
	format_query.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
	while (IoctlLocked(VIDIOC_ENUM_FMT, &format_query) >= 0) {
	v4l2_formats->insert(format_query.pixelformat);
	++format_query.index;
	}

	if (errno != EINVAL) {
	HAL_LOGE(
	"ENUM_FMT fails at index %d: %s", format_query.index, strerror(errno));
	return -ENODEV;
	}
	return 0;
	}

	int V4L2Wrapper::GetFormatFrameSizes(uint32_t v4l2_format,
	std::set<std::array<int32_t, 2>>* sizes) {
	v4l2_frmsizeenum size_query;
	memset(&size_query, 0, sizeof(size_query));
	size_query.pixel_format = v4l2_format;
	if (IoctlLocked(VIDIOC_ENUM_FRAMESIZES, &size_query) < 0) {
	HAL_LOGE("ENUM_FRAMESIZES failed: %s", strerror(errno));
	return -ENODEV;
	}
	if (size_query.type == V4L2_FRMSIZE_TYPE_DISCRETE) {
	// Discrete: enumerate all sizes using VIDIOC_ENUM_FRAMESIZES.
	// Assuming that a driver with discrete frame sizes has a reasonable number
	// of them.
	do {
	sizes->insert({{{static_cast<int32_t>(size_query.discrete.width),
	static_cast<int32_t>(size_query.discrete.height)}}});
	++size_query.index;
	} while (IoctlLocked(VIDIOC_ENUM_FRAMESIZES, &size_query) >= 0);
	if (errno != EINVAL) {
	HAL_LOGE("ENUM_FRAMESIZES fails at index %d: %s",
	size_query.index,
	strerror(errno));
	return -ENODEV;
	}
	} else {
	// Continuous/Step-wise: based on the stepwise struct returned by the query.
	// Fully listing all possible sizes, with large enough range/small enough
	// step size, may produce far too many potential sizes. Instead, find the
	// closest to a set of standard sizes.
	for (const auto size : kStandardSizes) {
	// Find the closest size, rounding up.
	uint32_t desired_width = size[0];
	uint32_t desired_height = size[1];
	if (desired_width < size_query.stepwise.min_width \|\|
	desired_height < size_query.stepwise.min_height) {
	HAL_LOGV("Standard size %u x %u is too small for format %d",
	desired_width,
	desired_height,
	v4l2_format);
	continue;
	} else if (desired_width > size_query.stepwise.max_width &&
	desired_height > size_query.stepwise.max_height) {
	HAL_LOGV("Standard size %u x %u is too big for format %d",
	desired_width,
	desired_height,
	v4l2_format);
	continue;
	}

	// Round up.
	uint32_t width_steps = (desired_width - size_query.stepwise.min_width +
	size_query.stepwise.step_width - 1) /
	size_query.stepwise.step_width;
	uint32_t height_steps = (desired_height - size_query.stepwise.min_height +
	size_query.stepwise.step_height - 1) /
	size_query.stepwise.step_height;
	sizes->insert(
	{{{static_cast<int32_t>(size_query.stepwise.min_width +
	width_steps * size_query.stepwise.step_width),
	static_cast<int32_t>(size_query.stepwise.min_height +
	height_steps *
	size_query.stepwise.step_height)}}});
	}
	}
	return 0;
	}

	// Converts a v4l2_fract with units of seconds to an int64_t with units of ns.
	inline int64_t FractToNs(const v4l2_fract& fract) {
	return (1000000000LL * fract.numerator) / fract.denominator;
	}

	int V4L2Wrapper::GetFormatFrameDurationRange(
	uint32_t v4l2_format,
	const std::array<int32_t, 2>& size,
	std::array<int64_t, 2>* duration_range) {
	// Potentially called so many times logging entry is a bad idea.

	v4l2_frmivalenum duration_query;
	memset(&duration_query, 0, sizeof(duration_query));
	duration_query.pixel_format = v4l2_format;
	duration_query.width = size[0];
	duration_query.height = size[1];
	if (IoctlLocked(VIDIOC_ENUM_FRAMEINTERVALS, &duration_query) < 0) {
	HAL_LOGE("ENUM_FRAMEINTERVALS failed: %s", strerror(errno));
	return -ENODEV;
	}

	int64_t min = std::numeric_limits<int64_t>::max();
	int64_t max = std::numeric_limits<int64_t>::min();
	if (duration_query.type == V4L2_FRMSIZE_TYPE_DISCRETE) {
	// Discrete: enumerate all durations using VIDIOC_ENUM_FRAMEINTERVALS.
	do {
	min = std::min(min, FractToNs(duration_query.discrete));
	max = std::max(max, FractToNs(duration_query.discrete));
	++duration_query.index;
	} while (IoctlLocked(VIDIOC_ENUM_FRAMEINTERVALS, &duration_query) >= 0);
	if (errno != EINVAL) {
	HAL_LOGE("ENUM_FRAMEINTERVALS fails at index %d: %s",
	duration_query.index,
	strerror(errno));
	return -ENODEV;
	}
	} else {
	// Continuous/Step-wise: simply convert the given min and max.
	min = FractToNs(duration_query.stepwise.min);
	max = FractToNs(duration_query.stepwise.max);
	}
	(*duration_range)[0] = min;
	(*duration_range)[1] = max;
	return 0;
	}

	int V4L2Wrapper::SetFormat(const StreamFormat& desired_format,
	uint32_t* result_max_buffers) {
	HAL_LOG_ENTER();

	if (format_ && desired_format == *format_) {
	HAL_LOGV("Already in correct format, skipping format setting.");
	*result_max_buffers = buffers_.size();
	return 0;
	}

	// Not in the correct format, set the new one.

	if (format_) {
	// If we had an old format, first request 0 buffers to inform the device
	// we're no longer using any previously "allocated" buffers from the old
	// format. This seems like it shouldn't be necessary for USERPTR memory,
	// and/or should happen from turning the stream off, but the driver
	// complained. May be a driver issue, or may be intended behavior.
	int res = RequestBuffers(0);
	if (res) {
	return res;
	}
	}

	// Set the camera to the new format.
	v4l2_format new_format;
	desired_format.FillFormatRequest(&new_format);
	// TODO(b/29334616): When async, this will need to check if the stream
	// is on, and if so, lock it off while setting format.

	if (IoctlLocked(VIDIOC_S_FMT, &new_format) < 0) {
	HAL_LOGE("S_FMT failed: %s", strerror(errno));
	return -ENODEV;
	}

	// Check that the driver actually set to the requested values.
	if (desired_format != new_format) {
	HAL_LOGE("Device doesn't support desired stream configuration.");
	return -EINVAL;
	}

	// Keep track of our new format.
	format_.reset(new StreamFormat(new_format));

	// Format changed, request new buffers.
	int res = RequestBuffers(1);
	if (res) {
	HAL_LOGE("Requesting buffers for new format failed.");
	return res;
	}
	*result_max_buffers = buffers_.size();
	return 0;
	}

	int V4L2Wrapper::RequestBuffers(uint32_t num_requested) {
	v4l2_requestbuffers req_buffers;
	memset(&req_buffers, 0, sizeof(req_buffers));
	req_buffers.type = format_->type();
	req_buffers.memory = V4L2_MEMORY_USERPTR;
	req_buffers.count = num_requested;

	int res = IoctlLocked(VIDIOC_REQBUFS, &req_buffers);
	// Calling REQBUFS releases all queued buffers back to the user.
	int gralloc_res = gralloc_->unlockAllBuffers();
	if (res < 0) {
	HAL_LOGE("REQBUFS failed: %s", strerror(errno));
	return -ENODEV;
	}
	if (gralloc_res < 0) {
	HAL_LOGE("Failed to unlock all buffers when setting up new buffers.");
	return gralloc_res;
	}

	// V4L2 will set req_buffers.count to a number of buffers it can handle.
	if (num_requested > 0 && req_buffers.count < 1) {
	HAL_LOGE("REQBUFS claims it can't handle any buffers.");
	return -ENODEV;
	}
	buffers_.resize(req_buffers.count, false);

	return 0;
	}

	int V4L2Wrapper::EnqueueBuffer(const camera3_stream_buffer_t* camera_buffer,
	uint32_t* enqueued_index) {
	if (!format_) {
	HAL_LOGE("Stream format must be set before enqueuing buffers.");
	return -ENODEV;
	}

	// Find a free buffer index. Could use some sort of persistent hinting
	// here to improve expected efficiency, but buffers_.size() is expected
	// to be low enough (<10 experimentally) that it's not worth it.
	int index = -1;
	{
	std::lock_guard<std::mutex> guard(buffer_queue_lock_);
	for (int i = 0; i < buffers_.size(); ++i) {
	if (!buffers_[i]) {
	index = i;
	break;
	}
	}
	}
	if (index < 0) {
	// Note: The HAL should be tracking the number of buffers in flight
	// for each stream, and should never overflow the device.
	HAL_LOGE("Cannot enqueue buffer: stream is already full.");
	return -ENODEV;
	}

	// Set up a v4l2 buffer struct.
	v4l2_buffer device_buffer;
	memset(&device_buffer, 0, sizeof(device_buffer));
	device_buffer.type = format_->type();
	device_buffer.index = index;

	// Use QUERYBUF to ensure our buffer/device is in good shape,
	// and fill out remaining fields.
	if (IoctlLocked(VIDIOC_QUERYBUF, &device_buffer) < 0) {
	HAL_LOGE("QUERYBUF fails: %s", strerror(errno));
	return -ENODEV;
	}

	// Lock the buffer for writing (fills in the user pointer field).
	int res =
	gralloc_->lock(camera_buffer, format_->bytes_per_line(), &device_buffer);
	if (res) {
	HAL_LOGE("Gralloc failed to lock buffer.");
	return res;
	}
	if (IoctlLocked(VIDIOC_QBUF, &device_buffer) < 0) {
	HAL_LOGE("QBUF fails: %s", strerror(errno));
	gralloc_->unlock(&device_buffer);
	return -ENODEV;
	}

	// Mark the buffer as in flight.
	std::lock_guard<std::mutex> guard(buffer_queue_lock_);
	buffers_[index] = true;

	if (enqueued_index) {
	*enqueued_index = index;
	}
	return 0;
	}

	int V4L2Wrapper::DequeueBuffer(uint32_t* dequeued_index) {
	if (!format_) {
	HAL_LOGV(
	"Format not set, so stream can't be on, "
	"so no buffers available for dequeueing");
	return -EAGAIN;
	}

	v4l2_buffer buffer;
	memset(&buffer, 0, sizeof(buffer));
	buffer.type = format_->type();
	buffer.memory = V4L2_MEMORY_USERPTR;
	int res = IoctlLocked(VIDIOC_DQBUF, &buffer);
	if (res) {
	if (errno == EAGAIN) {
	// Expected failure.
	return -EAGAIN;
	} else {
	// Unexpected failure.
	HAL_LOGE("DQBUF fails: %s", strerror(errno));
	return -ENODEV;
	}
	}

	// Mark the buffer as no longer in flight.
	{
	std::lock_guard<std::mutex> guard(buffer_queue_lock_);
	buffers_[buffer.index] = false;
	}

	// Now that we're done painting the buffer, we can unlock it.
	res = gralloc_->unlock(&buffer);
	if (res) {
	HAL_LOGE("Gralloc failed to unlock buffer after dequeueing.");
	return res;
	}

	if (dequeued_index) {
	*dequeued_index = buffer.index;
	}
	return 0;
	}

	} // namespace v4l2_camera_hal