modules/camera/3_4/metadata/partial_metadata_factory.h - platform/hardware/libhardware.git - Git at Google

 /*
  * Copyright (C) 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.
  */

 #ifndef V4L2_CAMERA_HAL_METADATA_CONTROL_FACTORY_H_
 #define V4L2_CAMERA_HAL_METADATA_CONTROL_FACTORY_H_

 #include "../common.h"
 #include "control.h"
 #include "menu_control_options.h"
 #include "no_effect_control_delegate.h"
 #include "ranged_converter.h"
 #include "slider_control_options.h"
 #include "state.h"
 #include "tagged_control_delegate.h"
 #include "tagged_control_options.h"
 #include "v4l2_control_delegate.h"

 namespace v4l2_camera_hal {

 enum class ControlType { kMenu, kSlider };

 // Static functions to create partial metadata. Nullptr is returned on failures.

 // FixedState: A state that doesn't change.
 template <typename T>
 static std::unique_ptr<State<T>> FixedState(int32_t tag, T value);

 // NoEffectOptionlessControl: A control that accepts any value,
 // and has no effect. A default value is given.
 template <typename T>
 static std::unique_ptr<Control<T>> NoEffectOptionlessControl(
     int32_t delegate_tag, T default_value);

 // NoEffectMenuControl: Some menu options, but they have no effect.
 template <typename T>
 static std::unique_ptr<Control<T>> NoEffectMenuControl(
     int32_t delegate_tag,
     int32_t options_tag,
     const std::vector<T>& options,
     std::map<int, T> default_values = {});

 // NoEffectSliderControl: A slider of options, but they have no effect.
 template <typename T>
 static std::unique_ptr<Control<T>> NoEffectSliderControl(
     int32_t delegate_tag,
     int32_t options_tag,
     T min,
     T max,
     std::map<int, T> default_values = {});

 // NoEffectControl: A control with no effect and only a single allowable
 // value. Chooses an appropriate ControlOptionsInterface depending on type.
 template <typename T>
 static std::unique_ptr<Control<T>> NoEffectControl(
     ControlType type,
     int32_t delegate_tag,
     int32_t options_tag,
     T value,
     std::map<int, T> default_values = {});

 // V4L2Control: A control corresponding to a V4L2 control.
 template <typename T>
 static std::unique_ptr<Control<T>> V4L2Control(
     ControlType type,
     int32_t delegate_tag,
     int32_t options_tag,
     std::shared_ptr<V4L2Wrapper> device,
     int control_id,
     std::shared_ptr<ConverterInterface<T, int32_t>> converter,
     std::map<int, T> default_values = {});

 // V4L2ControlOrDefault: Like V4L2Control, but if the V4L2Control fails to
 // initialize for some reason, this method will fall back to NoEffectControl
 // with an initial value defined by |fallback_default|.
 template <typename T>
 static std::unique_ptr<Control<T>> V4L2ControlOrDefault(
     ControlType type,
     int32_t delegate_tag,
     int32_t options_tag,
     std::shared_ptr<V4L2Wrapper> device,
     int control_id,
     std::shared_ptr<ConverterInterface<T, int32_t>> converter,
     T fallback_default,
     std::map<int, T> default_values = {});

 // -----------------------------------------------------------------------------

 template <typename T>
 std::unique_ptr<State<T>> FixedState(int32_t tag, T value) {
   HAL_LOG_ENTER();

   // Take advantage of ControlDelegate inheriting from StateDelegate;
   // This will only expose GetValue, not SetValue, so the default will
   // always be returned.
   return std::make_unique<State<T>>(
       tag, std::make_unique<NoEffectControlDelegate<T>>(value));
 }

 template <typename T>
 std::unique_ptr<Control<T>> NoEffectOptionlessControl(int32_t delegate_tag,
                                                       T default_value) {
   HAL_LOG_ENTER();

   return std::make_unique<Control<T>>(
       std::make_unique<TaggedControlDelegate<T>>(
           delegate_tag,
           std::make_unique<NoEffectControlDelegate<T>>(default_value)),
       nullptr);
 }

 template <typename T>
 std::unique_ptr<Control<T>> NoEffectMenuControl(
     int32_t delegate_tag,
     int32_t options_tag,
     const std::vector<T>& options,
     std::map<int, T> default_values) {
   HAL_LOG_ENTER();

   if (options.empty()) {
     HAL_LOGE("At least one option must be provided.");
     return nullptr;
   }

   return std::make_unique<Control<T>>(
       std::make_unique<TaggedControlDelegate<T>>(
           delegate_tag,
           std::make_unique<NoEffectControlDelegate<T>>(options[0])),
       std::make_unique<TaggedControlOptions<T>>(
           options_tag,
           std::make_unique<MenuControlOptions<T>>(options, default_values)));
 }

 template <typename T>
 std::unique_ptr<Control<T>> NoEffectSliderControl(
     int32_t delegate_tag,
     int32_t options_tag,
     T min,
     T max,
     std::map<int, T> default_values) {
   HAL_LOG_ENTER();

   return std::make_unique<Control<T>>(
       std::make_unique<TaggedControlDelegate<T>>(
           delegate_tag, std::make_unique<NoEffectControlDelegate<T>>(min)),
       std::make_unique<TaggedControlOptions<T>>(
           options_tag,
           std::make_unique<SliderControlOptions<T>>(min, max, default_values)));
 }

 template <typename T>
 std::unique_ptr<Control<T>> NoEffectControl(ControlType type,
                                             int32_t delegate_tag,
                                             int32_t options_tag,
                                             T value,
                                             std::map<int, T> default_values) {
   HAL_LOG_ENTER();

   switch (type) {
     case ControlType::kMenu:
       return NoEffectMenuControl<T>(
           delegate_tag, options_tag, {value}, default_values);
     case ControlType::kSlider:
       return NoEffectSliderControl(
           delegate_tag, options_tag, value, value, default_values);
   }
 }

 template <typename T>
 std::unique_ptr<Control<T>> V4L2Control(
     ControlType type,
     int32_t delegate_tag,
     int32_t options_tag,
     std::shared_ptr<V4L2Wrapper> device,
     int control_id,
     std::shared_ptr<ConverterInterface<T, int32_t>> converter,
     std::map<int, T> default_values) {
   HAL_LOG_ENTER();

   // Query the device.
   v4l2_query_ext_ctrl control_query;
   int res = device->QueryControl(control_id, &control_query);
   if (res) {
     HAL_LOGE("Failed to query control %d.", control_id);
     return nullptr;
   }

   int32_t control_min = static_cast<int32_t>(control_query.minimum);
   int32_t control_max = static_cast<int32_t>(control_query.maximum);
   int32_t control_step = static_cast<int32_t>(control_query.step);
   if (control_min > control_max) {
     HAL_LOGE("No acceptable values (min %d is greater than max %d).",
              control_min,
              control_max);
     return nullptr;
   }

   // Variables needed by the various switch statements.
   std::vector<T> options;
   T metadata_val;
   T metadata_min;
   T metadata_max;
   // Set up the result converter and result options based on type.
   std::shared_ptr<ConverterInterface<T, int32_t>> result_converter(converter);
   std::unique_ptr<ControlOptionsInterface<T>> result_options;
   switch (control_query.type) {
     case V4L2_CTRL_TYPE_BOOLEAN:
       if (type != ControlType::kMenu) {
         HAL_LOGE(
             "V4L2 control %d is of type %d, which isn't compatible with "
             "desired metadata control type %d",
             control_id,
             control_query.type,
             type);
         return nullptr;
       }

       // Convert each available option,
       // ignoring ones without a known conversion.
       for (int32_t i = control_min; i <= control_max; i += control_step) {
         res = converter->V4L2ToMetadata(i, &metadata_val);
         if (res == -EINVAL) {
           HAL_LOGV("V4L2 value %d for control %d has no metadata equivalent.",
                    i,
                    control_id);
           continue;
         } else if (res) {
           HAL_LOGE("Error converting value %d for control %d.", i, control_id);
           return nullptr;
         }
         options.push_back(metadata_val);
       }
       // Check to make sure there's at least one option.
       if (options.empty()) {
         HAL_LOGE("No valid options for control %d.", control_id);
         return nullptr;
       }

       result_options.reset(new MenuControlOptions<T>(options, default_values));
       // No converter changes necessary.
       break;
     case V4L2_CTRL_TYPE_INTEGER:
       if (type != ControlType::kSlider) {
         HAL_LOGE(
             "V4L2 control %d is of type %d, which isn't compatible with "
             "desired metadata control type %d",
             control_id,
             control_query.type,
             type);
         return nullptr;
       }

       // Upgrade to a range/step-clamping converter.
       result_converter.reset(new RangedConverter<T, int32_t>(
           converter, control_min, control_max, control_step));

       // Convert the min and max.
       res = result_converter->V4L2ToMetadata(control_min, &metadata_min);
       if (res) {
         HAL_LOGE(
             "Failed to convert V4L2 min value %d for control %d to metadata.",
             control_min,
             control_id);
         return nullptr;
       }
       res = result_converter->V4L2ToMetadata(control_max, &metadata_max);
       if (res) {
         HAL_LOGE(
             "Failed to convert V4L2 max value %d for control %d to metadata.",
             control_max,
             control_id);
         return nullptr;
       }
       result_options.reset(new SliderControlOptions<T>(
           metadata_min, metadata_max, default_values));
       break;
     default:
       HAL_LOGE("Control %d (%s) is of unsupported type %d",
                control_id,
                control_query.name,
                control_query.type);
       return nullptr;
   }

   // Construct the control.
   return std::make_unique<Control<T>>(
       std::make_unique<TaggedControlDelegate<T>>(
           delegate_tag,
           std::make_unique<V4L2ControlDelegate<T>>(
               device, control_id, result_converter)),
       std::make_unique<TaggedControlOptions<T>>(options_tag,
                                                 std::move(result_options)));
 }

 template <typename T>
 std::unique_ptr<Control<T>> V4L2ControlOrDefault(
     ControlType type,
     int32_t delegate_tag,
     int32_t options_tag,
     std::shared_ptr<V4L2Wrapper> device,
     int control_id,
     std::shared_ptr<ConverterInterface<T, int32_t>> converter,
     T fallback_default,
     std::map<int, T> default_values) {
   HAL_LOG_ENTER();

   std::unique_ptr<Control<T>> result = V4L2Control(type,
                                                    delegate_tag,
                                                    options_tag,
                                                    device,
                                                    control_id,
                                                    converter,
                                                    default_values);
   if (!result) {
     result = NoEffectControl(
         type, delegate_tag, options_tag, fallback_default, default_values);
   }
   return result;
 }

 }  // namespace v4l2_camera_hal

 #endif  // V4L2_CAMERA_HAL_METADATA_CONTROL_FACTORY_H_
	/*
	* Copyright (C) 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.
	*/

	#ifndef V4L2_CAMERA_HAL_METADATA_CONTROL_FACTORY_H_
	#define V4L2_CAMERA_HAL_METADATA_CONTROL_FACTORY_H_

	#include "../common.h"
	#include "control.h"
	#include "menu_control_options.h"
	#include "no_effect_control_delegate.h"
	#include "ranged_converter.h"
	#include "slider_control_options.h"
	#include "state.h"
	#include "tagged_control_delegate.h"
	#include "tagged_control_options.h"
	#include "v4l2_control_delegate.h"

	namespace v4l2_camera_hal {

	enum class ControlType { kMenu, kSlider };

	// Static functions to create partial metadata. Nullptr is returned on failures.

	// FixedState: A state that doesn't change.
	template <typename T>
	static std::unique_ptr<State<T>> FixedState(int32_t tag, T value);

	// NoEffectOptionlessControl: A control that accepts any value,
	// and has no effect. A default value is given.
	template <typename T>
	static std::unique_ptr<Control<T>> NoEffectOptionlessControl(
	int32_t delegate_tag, T default_value);

	// NoEffectMenuControl: Some menu options, but they have no effect.
	template <typename T>
	static std::unique_ptr<Control<T>> NoEffectMenuControl(
	int32_t delegate_tag,
	int32_t options_tag,
	const std::vector<T>& options,
	std::map<int, T> default_values = {});

	// NoEffectSliderControl: A slider of options, but they have no effect.
	template <typename T>
	static std::unique_ptr<Control<T>> NoEffectSliderControl(
	int32_t delegate_tag,
	int32_t options_tag,
	T min,
	T max,
	std::map<int, T> default_values = {});

	// NoEffectControl: A control with no effect and only a single allowable
	// value. Chooses an appropriate ControlOptionsInterface depending on type.
	template <typename T>
	static std::unique_ptr<Control<T>> NoEffectControl(
	ControlType type,
	int32_t delegate_tag,
	int32_t options_tag,
	T value,
	std::map<int, T> default_values = {});

	// V4L2Control: A control corresponding to a V4L2 control.
	template <typename T>
	static std::unique_ptr<Control<T>> V4L2Control(
	ControlType type,
	int32_t delegate_tag,
	int32_t options_tag,
	std::shared_ptr<V4L2Wrapper> device,
	int control_id,
	std::shared_ptr<ConverterInterface<T, int32_t>> converter,
	std::map<int, T> default_values = {});

	// V4L2ControlOrDefault: Like V4L2Control, but if the V4L2Control fails to
	// initialize for some reason, this method will fall back to NoEffectControl
	// with an initial value defined by \|fallback_default\|.
	template <typename T>
	static std::unique_ptr<Control<T>> V4L2ControlOrDefault(
	ControlType type,
	int32_t delegate_tag,
	int32_t options_tag,
	std::shared_ptr<V4L2Wrapper> device,
	int control_id,
	std::shared_ptr<ConverterInterface<T, int32_t>> converter,
	T fallback_default,
	std::map<int, T> default_values = {});

	// -----------------------------------------------------------------------------

	template <typename T>
	std::unique_ptr<State<T>> FixedState(int32_t tag, T value) {
	HAL_LOG_ENTER();

	// Take advantage of ControlDelegate inheriting from StateDelegate;
	// This will only expose GetValue, not SetValue, so the default will
	// always be returned.
	return std::make_unique<State<T>>(
	tag, std::make_unique<NoEffectControlDelegate<T>>(value));
	}

	template <typename T>
	std::unique_ptr<Control<T>> NoEffectOptionlessControl(int32_t delegate_tag,
	T default_value) {
	HAL_LOG_ENTER();

	return std::make_unique<Control<T>>(
	std::make_unique<TaggedControlDelegate<T>>(
	delegate_tag,
	std::make_unique<NoEffectControlDelegate<T>>(default_value)),
	nullptr);
	}

	template <typename T>
	std::unique_ptr<Control<T>> NoEffectMenuControl(
	int32_t delegate_tag,
	int32_t options_tag,
	const std::vector<T>& options,
	std::map<int, T> default_values) {
	HAL_LOG_ENTER();

	if (options.empty()) {
	HAL_LOGE("At least one option must be provided.");
	return nullptr;
	}

	return std::make_unique<Control<T>>(
	std::make_unique<TaggedControlDelegate<T>>(
	delegate_tag,
	std::make_unique<NoEffectControlDelegate<T>>(options[0])),
	std::make_unique<TaggedControlOptions<T>>(
	options_tag,
	std::make_unique<MenuControlOptions<T>>(options, default_values)));
	}

	template <typename T>
	std::unique_ptr<Control<T>> NoEffectSliderControl(
	int32_t delegate_tag,
	int32_t options_tag,
	T min,
	T max,
	std::map<int, T> default_values) {
	HAL_LOG_ENTER();

	return std::make_unique<Control<T>>(
	std::make_unique<TaggedControlDelegate<T>>(
	delegate_tag, std::make_unique<NoEffectControlDelegate<T>>(min)),
	std::make_unique<TaggedControlOptions<T>>(
	options_tag,
	std::make_unique<SliderControlOptions<T>>(min, max, default_values)));
	}

	template <typename T>
	std::unique_ptr<Control<T>> NoEffectControl(ControlType type,
	int32_t delegate_tag,
	int32_t options_tag,
	T value,
	std::map<int, T> default_values) {
	HAL_LOG_ENTER();

	switch (type) {
	case ControlType::kMenu:
	return NoEffectMenuControl<T>(
	delegate_tag, options_tag, {value}, default_values);
	case ControlType::kSlider:
	return NoEffectSliderControl(
	delegate_tag, options_tag, value, value, default_values);
	}
	}

	template <typename T>
	std::unique_ptr<Control<T>> V4L2Control(
	ControlType type,
	int32_t delegate_tag,
	int32_t options_tag,
	std::shared_ptr<V4L2Wrapper> device,
	int control_id,
	std::shared_ptr<ConverterInterface<T, int32_t>> converter,
	std::map<int, T> default_values) {
	HAL_LOG_ENTER();

	// Query the device.
	v4l2_query_ext_ctrl control_query;
	int res = device->QueryControl(control_id, &control_query);
	if (res) {
	HAL_LOGE("Failed to query control %d.", control_id);
	return nullptr;
	}

	int32_t control_min = static_cast<int32_t>(control_query.minimum);
	int32_t control_max = static_cast<int32_t>(control_query.maximum);
	int32_t control_step = static_cast<int32_t>(control_query.step);
	if (control_min > control_max) {
	HAL_LOGE("No acceptable values (min %d is greater than max %d).",
	control_min,
	control_max);
	return nullptr;
	}

	// Variables needed by the various switch statements.
	std::vector<T> options;
	T metadata_val;
	T metadata_min;
	T metadata_max;
	// Set up the result converter and result options based on type.
	std::shared_ptr<ConverterInterface<T, int32_t>> result_converter(converter);
	std::unique_ptr<ControlOptionsInterface<T>> result_options;
	switch (control_query.type) {
	case V4L2_CTRL_TYPE_BOOLEAN:
	if (type != ControlType::kMenu) {
	HAL_LOGE(
	"V4L2 control %d is of type %d, which isn't compatible with "
	"desired metadata control type %d",
	control_id,
	control_query.type,
	type);
	return nullptr;
	}

	// Convert each available option,
	// ignoring ones without a known conversion.
	for (int32_t i = control_min; i <= control_max; i += control_step) {
	res = converter->V4L2ToMetadata(i, &metadata_val);
	if (res == -EINVAL) {
	HAL_LOGV("V4L2 value %d for control %d has no metadata equivalent.",
	i,
	control_id);
	continue;
	} else if (res) {
	HAL_LOGE("Error converting value %d for control %d.", i, control_id);
	return nullptr;
	}
	options.push_back(metadata_val);
	}
	// Check to make sure there's at least one option.
	if (options.empty()) {
	HAL_LOGE("No valid options for control %d.", control_id);
	return nullptr;
	}

	result_options.reset(new MenuControlOptions<T>(options, default_values));
	// No converter changes necessary.
	break;
	case V4L2_CTRL_TYPE_INTEGER:
	if (type != ControlType::kSlider) {
	HAL_LOGE(
	"V4L2 control %d is of type %d, which isn't compatible with "
	"desired metadata control type %d",
	control_id,
	control_query.type,
	type);
	return nullptr;
	}

	// Upgrade to a range/step-clamping converter.
	result_converter.reset(new RangedConverter<T, int32_t>(
	converter, control_min, control_max, control_step));

	// Convert the min and max.
	res = result_converter->V4L2ToMetadata(control_min, &metadata_min);
	if (res) {
	HAL_LOGE(
	"Failed to convert V4L2 min value %d for control %d to metadata.",
	control_min,
	control_id);
	return nullptr;
	}
	res = result_converter->V4L2ToMetadata(control_max, &metadata_max);
	if (res) {
	HAL_LOGE(
	"Failed to convert V4L2 max value %d for control %d to metadata.",
	control_max,
	control_id);
	return nullptr;
	}
	result_options.reset(new SliderControlOptions<T>(
	metadata_min, metadata_max, default_values));
	break;
	default:
	HAL_LOGE("Control %d (%s) is of unsupported type %d",
	control_id,
	control_query.name,
	control_query.type);
	return nullptr;
	}

	// Construct the control.
	return std::make_unique<Control<T>>(
	std::make_unique<TaggedControlDelegate<T>>(
	delegate_tag,
	std::make_unique<V4L2ControlDelegate<T>>(
	device, control_id, result_converter)),
	std::make_unique<TaggedControlOptions<T>>(options_tag,
	std::move(result_options)));
	}

	template <typename T>
	std::unique_ptr<Control<T>> V4L2ControlOrDefault(
	ControlType type,
	int32_t delegate_tag,
	int32_t options_tag,
	std::shared_ptr<V4L2Wrapper> device,
	int control_id,
	std::shared_ptr<ConverterInterface<T, int32_t>> converter,
	T fallback_default,
	std::map<int, T> default_values) {
	HAL_LOG_ENTER();

	std::unique_ptr<Control<T>> result = V4L2Control(type,
	delegate_tag,
	options_tag,
	device,
	control_id,
	converter,
	default_values);
	if (!result) {
	result = NoEffectControl(
	type, delegate_tag, options_tag, fallback_default, default_values);
	}
	return result;
	}

	} // namespace v4l2_camera_hal

	#endif // V4L2_CAMERA_HAL_METADATA_CONTROL_FACTORY_H_