modules/camera/3_4/v4l2_camera.cpp - android_hardware_libhardware - Gitiles

 /*
  * 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_camera.h"

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

 #include <cstdlib>

 #include <camera/CameraMetadata.h>
 #include <hardware/camera3.h>

 #include "common.h"
 #include "metadata/metadata_common.h"
 #include "stream_format.h"
 #include "v4l2_metadata_factory.h"

 #define ARRAY_SIZE(a) (sizeof(a) / sizeof(*(a)))

 namespace v4l2_camera_hal {

 // Helper function for managing metadata.
 static std::vector<int32_t> getMetadataKeys(const camera_metadata_t* metadata) {
   std::vector<int32_t> keys;
   size_t num_entries = get_camera_metadata_entry_count(metadata);
   for (size_t i = 0; i < num_entries; ++i) {
     camera_metadata_ro_entry_t entry;
     get_camera_metadata_ro_entry(metadata, i, &entry);
     keys.push_back(entry.tag);
   }
   return keys;
 }

 V4L2Camera* V4L2Camera::NewV4L2Camera(int id, const std::string path) {
   HAL_LOG_ENTER();

   std::shared_ptr<V4L2Wrapper> v4l2_wrapper(V4L2Wrapper::NewV4L2Wrapper(path));
   if (!v4l2_wrapper) {
     HAL_LOGE("Failed to initialize V4L2 wrapper.");
     return nullptr;
   }

   std::unique_ptr<Metadata> metadata;
   int res = GetV4L2Metadata(v4l2_wrapper, &metadata);
   if (res) {
     HAL_LOGE("Failed to initialize V4L2 metadata: %d", res);
     return nullptr;
   }

   return new V4L2Camera(id, std::move(v4l2_wrapper), std::move(metadata));
 }

 V4L2Camera::V4L2Camera(int id,
                        std::shared_ptr<V4L2Wrapper> v4l2_wrapper,
                        std::unique_ptr<Metadata> metadata)
     : default_camera_hal::Camera(id),
       device_(std::move(v4l2_wrapper)),
       metadata_(std::move(metadata)),
       max_input_streams_(0),
       max_output_streams_({{0, 0, 0}}) {
   HAL_LOG_ENTER();
 }

 V4L2Camera::~V4L2Camera() {
   HAL_LOG_ENTER();
 }

 int V4L2Camera::connect() {
   HAL_LOG_ENTER();

   if (connection_) {
     HAL_LOGE("Already connected. Please disconnect and try again.");
     return -EIO;
   }

   connection_.reset(new V4L2Wrapper::Connection(device_));
   if (connection_->status()) {
     HAL_LOGE("Failed to connect to device.");
     return connection_->status();
   }

   // TODO(b/29185945): confirm this is a supported device.
   // This is checked by the HAL, but the device at |device_|'s 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)

   // TODO(b/29158098): Inform service of any flashes that are no longer
   // available because this camera is in use.
   return 0;
 }

 void V4L2Camera::disconnect() {
   HAL_LOG_ENTER();

   connection_.reset();

   // TODO(b/29158098): Inform service of any flashes that are available again
   // because this camera is no longer in use.
 }

 int V4L2Camera::initStaticInfo(android::CameraMetadata* out) {
   HAL_LOG_ENTER();

   int res = metadata_->FillStaticMetadata(out);
   if (res) {
     HAL_LOGE("Failed to get static metadata.");
     return res;
   }

   // Extract max streams for use in verifying stream configs.
   res = SingleTagValue(
       *out, ANDROID_REQUEST_MAX_NUM_INPUT_STREAMS, &max_input_streams_);
   if (res) {
     HAL_LOGE("Failed to get max num input streams from static metadata.");
     return res;
   }
   res = SingleTagValue(
       *out, ANDROID_REQUEST_MAX_NUM_OUTPUT_STREAMS, &max_output_streams_);
   if (res) {
     HAL_LOGE("Failed to get max num output streams from static metadata.");
     return res;
   }

   return 0;
 }

 int V4L2Camera::initTemplate(int type, android::CameraMetadata* out) {
   HAL_LOG_ENTER();

   return metadata_->GetRequestTemplate(type, out);
 }

 void V4L2Camera::initDeviceInfo(camera_info_t* info) {
   HAL_LOG_ENTER();

   // TODO(b/31044975): move this into device interface.
   // For now, just constants.
   info->resource_cost = 100;
   info->conflicting_devices = nullptr;
   info->conflicting_devices_length = 0;
 }

 int V4L2Camera::initDevice() {
   HAL_LOG_ENTER();
   // Nothing to do.
   return 0;
 }

 int V4L2Camera::enqueueBuffer(const camera3_stream_buffer_t* camera_buffer) {
   HAL_LOG_ENTER();

   int res = device_->EnqueueBuffer(camera_buffer);
   if (res) {
     HAL_LOGE("Device failed to enqueue buffer.");
     return res;
   }

   // Turn on the stream.
   // TODO(b/29334616): Lock around stream on/off access, only start stream
   // if not already on. (For now, since it's synchronous, it will always be
   // turned off before another call to this function).
   res = device_->StreamOn();
   if (res) {
     HAL_LOGE("Device failed to turn on stream.");
     return res;
   }

   // TODO(b/29334616): Enqueueing and dequeueing should be separate worker
   // threads, not in the same function.

   // Dequeue the buffer.
   v4l2_buffer result_buffer;
   res = device_->DequeueBuffer(&result_buffer);
   if (res) {
     HAL_LOGE("Device failed to dequeue buffer.");
     return res;
   }

   // All done, cleanup.
   // TODO(b/29334616): Lock around stream on/off access, only stop stream if
   // buffer queue is empty (synchronously, there's only ever 1 buffer in the
   // queue at a time, so this is safe).
   res = device_->StreamOff();
   if (res) {
     HAL_LOGE("Device failed to turn off stream.");
     return res;
   }

   return 0;
 }

 int V4L2Camera::getResultSettings(android::CameraMetadata* metadata,
                                   uint64_t* timestamp) {
   HAL_LOG_ENTER();

   // Get the results.
   int res = metadata_->FillResultMetadata(metadata);
   if (res) {
     HAL_LOGE("Failed to fill result metadata.");
     return res;
   }

   // Extract the timestamp.
   int64_t frame_time = 0;
   res = SingleTagValue(*metadata, ANDROID_SENSOR_TIMESTAMP, &frame_time);
   if (res) {
     HAL_LOGE("Failed to extract timestamp from result metadata");
     return res;
   }
   *timestamp = static_cast<uint64_t>(frame_time);

   return 0;
 }

 bool V4L2Camera::isSupportedStreamSet(default_camera_hal::Stream** streams,
                                       int count,
                                       uint32_t mode) {
   HAL_LOG_ENTER();

   if (mode != CAMERA3_STREAM_CONFIGURATION_NORMAL_MODE) {
     HAL_LOGE("Unsupported stream configuration mode: %d", mode);
     return false;
   }

   // This should be checked by the caller, but put here as a sanity check.
   if (count < 1) {
     HAL_LOGE("Must request at least 1 stream");
     return false;
   }

   // Count the number of streams of each type.
   int32_t num_input = 0;
   int32_t num_raw = 0;
   int32_t num_stalling = 0;
   int32_t num_non_stalling = 0;
   for (int i = 0; i < count; ++i) {
     default_camera_hal::Stream* stream = streams[i];

     if (stream->isInputType()) {
       ++num_input;
     }

     if (stream->isOutputType()) {
       StreamFormat format(*stream);
       switch (format.Category()) {
         case kFormatCategoryRaw:
           ++num_raw;
         case kFormatCategoryStalling:
           ++num_stalling;
           break;
         case kFormatCategoryNonStalling:
           ++num_non_stalling;
           break;
         case kFormatCategoryUnknown:  // Fall through.
         default:
           HAL_LOGE(
               "Unsupported format for stream %d: %d", i, stream->getFormat());
           return false;
       }
     }
   }

   if (num_input > max_input_streams_ || num_raw > max_output_streams_[0] ||
       num_non_stalling > max_output_streams_[1] ||
       num_stalling > max_output_streams_[2]) {
     HAL_LOGE(
         "Invalid stream configuration: %d input, %d RAW, %d non-stalling, "
         "%d stalling (max supported: %d input, %d RAW, %d non-stalling, "
         "%d stalling)",
         max_input_streams_,
         max_output_streams_[0],
         max_output_streams_[1],
         max_output_streams_[2],
         num_input,
         num_raw,
         num_non_stalling,
         num_stalling);
     return false;
   }

   // TODO(b/29939583): The above logic should be all that's necessary,
   // but V4L2 doesn't actually support more than 1 stream at a time. So for now,
   // if not all streams are the same format and size, error. Note that this
   // means the HAL is not spec-compliant; the requested streams are technically
   // valid and it is not technically allowed to error once it has reached this
   // point.
   int format = streams[0]->getFormat();
   uint32_t width = streams[0]->getWidth();
   uint32_t height = streams[0]->getHeight();
   for (int i = 1; i < count; ++i) {
     const default_camera_hal::Stream* stream = streams[i];
     if (stream->getFormat() != format || stream->getWidth() != width ||
         stream->getHeight() != height) {
       HAL_LOGE(
           "V4L2 only supports 1 stream configuration at a time "
           "(stream 0 is format %d, width %u, height %u, "
           "stream %d is format %d, width %u, height %u).",
           format,
           width,
           height,
           i,
           stream->getFormat(),
           stream->getWidth(),
           stream->getHeight());
       return false;
     }
   }

   return true;
 }

 int V4L2Camera::setupStream(default_camera_hal::Stream* stream,
                             uint32_t* max_buffers) {
   HAL_LOG_ENTER();

   if (stream->getRotation() != CAMERA3_STREAM_ROTATION_0) {
     HAL_LOGE("Rotation %d not supported", stream->getRotation());
     return -EINVAL;
   }

   // Doesn't matter what was requested, we always use dataspace V0_JFIF.
   // Note: according to camera3.h, this isn't allowed, but etalvala@google.com
   // claims it's underdocumented; the implementation lets the HAL overwrite it.
   stream->setDataSpace(HAL_DATASPACE_V0_JFIF);

   int res = device_->SetFormat(*stream, max_buffers);
   if (res) {
     HAL_LOGE("Failed to set device to correct format for stream.");
     return res;
   }
   // Sanity check.
   if (*max_buffers < 1) {
     HAL_LOGE("Setting format resulted in an invalid maximum of %u buffers.",
              *max_buffers);
     return -ENODEV;
   }

   return 0;
 }

 bool V4L2Camera::isValidCaptureSettings(
     const android::CameraMetadata& settings) {
   HAL_LOG_ENTER();

   return metadata_->IsValidRequest(settings);
 }

 int V4L2Camera::setSettings(const android::CameraMetadata& new_settings) {
   HAL_LOG_ENTER();

   return metadata_->SetRequestSettings(new_settings);
 }

 }  // 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_camera.h"

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

	#include <cstdlib>

	#include <camera/CameraMetadata.h>
	#include <hardware/camera3.h>

	#include "common.h"
	#include "metadata/metadata_common.h"
	#include "stream_format.h"
	#include "v4l2_metadata_factory.h"

	#define ARRAY_SIZE(a) (sizeof(a) / sizeof(*(a)))

	namespace v4l2_camera_hal {

	// Helper function for managing metadata.
	static std::vector<int32_t> getMetadataKeys(const camera_metadata_t* metadata) {
	std::vector<int32_t> keys;
	size_t num_entries = get_camera_metadata_entry_count(metadata);
	for (size_t i = 0; i < num_entries; ++i) {
	camera_metadata_ro_entry_t entry;
	get_camera_metadata_ro_entry(metadata, i, &entry);
	keys.push_back(entry.tag);
	}
	return keys;
	}

	V4L2Camera* V4L2Camera::NewV4L2Camera(int id, const std::string path) {
	HAL_LOG_ENTER();

	std::shared_ptr<V4L2Wrapper> v4l2_wrapper(V4L2Wrapper::NewV4L2Wrapper(path));
	if (!v4l2_wrapper) {
	HAL_LOGE("Failed to initialize V4L2 wrapper.");
	return nullptr;
	}

	std::unique_ptr<Metadata> metadata;
	int res = GetV4L2Metadata(v4l2_wrapper, &metadata);
	if (res) {
	HAL_LOGE("Failed to initialize V4L2 metadata: %d", res);
	return nullptr;
	}

	return new V4L2Camera(id, std::move(v4l2_wrapper), std::move(metadata));
	}

	V4L2Camera::V4L2Camera(int id,
	std::shared_ptr<V4L2Wrapper> v4l2_wrapper,
	std::unique_ptr<Metadata> metadata)
	: default_camera_hal::Camera(id),
	device_(std::move(v4l2_wrapper)),
	metadata_(std::move(metadata)),
	max_input_streams_(0),
	max_output_streams_({{0, 0, 0}}) {
	HAL_LOG_ENTER();
	}

	V4L2Camera::~V4L2Camera() {
	HAL_LOG_ENTER();
	}

	int V4L2Camera::connect() {
	HAL_LOG_ENTER();

	if (connection_) {
	HAL_LOGE("Already connected. Please disconnect and try again.");
	return -EIO;
	}

	connection_.reset(new V4L2Wrapper::Connection(device_));
	if (connection_->status()) {
	HAL_LOGE("Failed to connect to device.");
	return connection_->status();
	}

	// TODO(b/29185945): confirm this is a supported device.
	// This is checked by the HAL, but the device at \|device_\|'s 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)

	// TODO(b/29158098): Inform service of any flashes that are no longer
	// available because this camera is in use.
	return 0;
	}

	void V4L2Camera::disconnect() {
	HAL_LOG_ENTER();

	connection_.reset();

	// TODO(b/29158098): Inform service of any flashes that are available again
	// because this camera is no longer in use.
	}

	int V4L2Camera::initStaticInfo(android::CameraMetadata* out) {
	HAL_LOG_ENTER();

	int res = metadata_->FillStaticMetadata(out);
	if (res) {
	HAL_LOGE("Failed to get static metadata.");
	return res;
	}

	// Extract max streams for use in verifying stream configs.
	res = SingleTagValue(
	*out, ANDROID_REQUEST_MAX_NUM_INPUT_STREAMS, &max_input_streams_);
	if (res) {
	HAL_LOGE("Failed to get max num input streams from static metadata.");
	return res;
	}
	res = SingleTagValue(
	*out, ANDROID_REQUEST_MAX_NUM_OUTPUT_STREAMS, &max_output_streams_);
	if (res) {
	HAL_LOGE("Failed to get max num output streams from static metadata.");
	return res;
	}

	return 0;
	}

	int V4L2Camera::initTemplate(int type, android::CameraMetadata* out) {
	HAL_LOG_ENTER();

	return metadata_->GetRequestTemplate(type, out);
	}

	void V4L2Camera::initDeviceInfo(camera_info_t* info) {
	HAL_LOG_ENTER();

	// TODO(b/31044975): move this into device interface.
	// For now, just constants.
	info->resource_cost = 100;
	info->conflicting_devices = nullptr;
	info->conflicting_devices_length = 0;
	}

	int V4L2Camera::initDevice() {
	HAL_LOG_ENTER();
	// Nothing to do.
	return 0;
	}

	int V4L2Camera::enqueueBuffer(const camera3_stream_buffer_t* camera_buffer) {
	HAL_LOG_ENTER();

	int res = device_->EnqueueBuffer(camera_buffer);
	if (res) {
	HAL_LOGE("Device failed to enqueue buffer.");
	return res;
	}

	// Turn on the stream.
	// TODO(b/29334616): Lock around stream on/off access, only start stream
	// if not already on. (For now, since it's synchronous, it will always be
	// turned off before another call to this function).
	res = device_->StreamOn();
	if (res) {
	HAL_LOGE("Device failed to turn on stream.");
	return res;
	}

	// TODO(b/29334616): Enqueueing and dequeueing should be separate worker
	// threads, not in the same function.

	// Dequeue the buffer.
	v4l2_buffer result_buffer;
	res = device_->DequeueBuffer(&result_buffer);
	if (res) {
	HAL_LOGE("Device failed to dequeue buffer.");
	return res;
	}

	// All done, cleanup.
	// TODO(b/29334616): Lock around stream on/off access, only stop stream if
	// buffer queue is empty (synchronously, there's only ever 1 buffer in the
	// queue at a time, so this is safe).
	res = device_->StreamOff();
	if (res) {
	HAL_LOGE("Device failed to turn off stream.");
	return res;
	}

	return 0;
	}

	int V4L2Camera::getResultSettings(android::CameraMetadata* metadata,
	uint64_t* timestamp) {
	HAL_LOG_ENTER();

	// Get the results.
	int res = metadata_->FillResultMetadata(metadata);
	if (res) {
	HAL_LOGE("Failed to fill result metadata.");
	return res;
	}

	// Extract the timestamp.
	int64_t frame_time = 0;
	res = SingleTagValue(*metadata, ANDROID_SENSOR_TIMESTAMP, &frame_time);
	if (res) {
	HAL_LOGE("Failed to extract timestamp from result metadata");
	return res;
	}
	*timestamp = static_cast<uint64_t>(frame_time);

	return 0;
	}

	bool V4L2Camera::isSupportedStreamSet(default_camera_hal::Stream** streams,
	int count,
	uint32_t mode) {
	HAL_LOG_ENTER();

	if (mode != CAMERA3_STREAM_CONFIGURATION_NORMAL_MODE) {
	HAL_LOGE("Unsupported stream configuration mode: %d", mode);
	return false;
	}

	// This should be checked by the caller, but put here as a sanity check.
	if (count < 1) {
	HAL_LOGE("Must request at least 1 stream");
	return false;
	}

	// Count the number of streams of each type.
	int32_t num_input = 0;
	int32_t num_raw = 0;
	int32_t num_stalling = 0;
	int32_t num_non_stalling = 0;
	for (int i = 0; i < count; ++i) {
	default_camera_hal::Stream* stream = streams[i];

	if (stream->isInputType()) {
	++num_input;
	}

	if (stream->isOutputType()) {
	StreamFormat format(*stream);
	switch (format.Category()) {
	case kFormatCategoryRaw:
	++num_raw;
	case kFormatCategoryStalling:
	++num_stalling;
	break;
	case kFormatCategoryNonStalling:
	++num_non_stalling;
	break;
	case kFormatCategoryUnknown: // Fall through.
	default:
	HAL_LOGE(
	"Unsupported format for stream %d: %d", i, stream->getFormat());
	return false;
	}
	}
	}

	if (num_input > max_input_streams_ \|\| num_raw > max_output_streams_[0] \|\|
	num_non_stalling > max_output_streams_[1] \|\|
	num_stalling > max_output_streams_[2]) {
	HAL_LOGE(
	"Invalid stream configuration: %d input, %d RAW, %d non-stalling, "
	"%d stalling (max supported: %d input, %d RAW, %d non-stalling, "
	"%d stalling)",
	max_input_streams_,
	max_output_streams_[0],
	max_output_streams_[1],
	max_output_streams_[2],
	num_input,
	num_raw,
	num_non_stalling,
	num_stalling);
	return false;
	}

	// TODO(b/29939583): The above logic should be all that's necessary,
	// but V4L2 doesn't actually support more than 1 stream at a time. So for now,
	// if not all streams are the same format and size, error. Note that this
	// means the HAL is not spec-compliant; the requested streams are technically
	// valid and it is not technically allowed to error once it has reached this
	// point.
	int format = streams[0]->getFormat();
	uint32_t width = streams[0]->getWidth();
	uint32_t height = streams[0]->getHeight();
	for (int i = 1; i < count; ++i) {
	const default_camera_hal::Stream* stream = streams[i];
	if (stream->getFormat() != format \|\| stream->getWidth() != width \|\|
	stream->getHeight() != height) {
	HAL_LOGE(
	"V4L2 only supports 1 stream configuration at a time "
	"(stream 0 is format %d, width %u, height %u, "
	"stream %d is format %d, width %u, height %u).",
	format,
	width,
	height,
	i,
	stream->getFormat(),
	stream->getWidth(),
	stream->getHeight());
	return false;
	}
	}

	return true;
	}

	int V4L2Camera::setupStream(default_camera_hal::Stream* stream,
	uint32_t* max_buffers) {
	HAL_LOG_ENTER();

	if (stream->getRotation() != CAMERA3_STREAM_ROTATION_0) {
	HAL_LOGE("Rotation %d not supported", stream->getRotation());
	return -EINVAL;
	}

	// Doesn't matter what was requested, we always use dataspace V0_JFIF.
	// Note: according to camera3.h, this isn't allowed, but etalvala@google.com
	// claims it's underdocumented; the implementation lets the HAL overwrite it.
	stream->setDataSpace(HAL_DATASPACE_V0_JFIF);

	int res = device_->SetFormat(*stream, max_buffers);
	if (res) {
	HAL_LOGE("Failed to set device to correct format for stream.");
	return res;
	}
	// Sanity check.
	if (*max_buffers < 1) {
	HAL_LOGE("Setting format resulted in an invalid maximum of %u buffers.",
	*max_buffers);
	return -ENODEV;
	}

	return 0;
	}

	bool V4L2Camera::isValidCaptureSettings(
	const android::CameraMetadata& settings) {
	HAL_LOG_ENTER();

	return metadata_->IsValidRequest(settings);
	}

	int V4L2Camera::setSettings(const android::CameraMetadata& new_settings) {
	HAL_LOG_ENTER();

	return metadata_->SetRequestSettings(new_settings);
	}

	} // namespace v4l2_camera_hal