diff options
Diffstat (limited to 'devices')
6 files changed, 185 insertions, 110 deletions
diff --git a/devices/EmulatedCamera/hwl/EmulatedLogicalRequestState.cpp b/devices/EmulatedCamera/hwl/EmulatedLogicalRequestState.cpp index dd1c3b8..20850ce 100644 --- a/devices/EmulatedCamera/hwl/EmulatedLogicalRequestState.cpp +++ b/devices/EmulatedCamera/hwl/EmulatedLogicalRequestState.cpp @@ -16,6 +16,7 @@ #define LOG_TAG "EmulatedLogicalState" #define ATRACE_TAG ATRACE_TAG_CAMERA +//#define LOG_NDEBUG 0 #include "EmulatedLogicalRequestState.h" @@ -37,32 +38,20 @@ status_t EmulatedLogicalRequestState::Initialize( std::unique_ptr<HalCameraMetadata> static_meta, PhysicalDeviceMapPtr physical_devices) { if ((physical_devices.get() != nullptr) && (!physical_devices->empty())) { + zoom_ratio_physical_camera_info_ = GetZoomRatioPhysicalCameraInfo( + static_meta.get(), physical_devices.get()); + physical_device_map_ = std::move(physical_devices); - // If possible map the available focal lengths to individual physical devices - camera_metadata_ro_entry_t logical_entry, physical_entry; - auto ret = static_meta->Get(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS, - &logical_entry); - if ((ret == OK) && (logical_entry.count > 1)) { - for (size_t i = 0; i < logical_entry.count; i++) { - for (const auto& it : *physical_device_map_) { - if (it.second.first != CameraDeviceStatus::kPresent) { - continue; - } - ret = it.second.second->Get(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS, - &physical_entry); - if ((ret == OK) && (physical_entry.count > 0)) { - if (logical_entry.data.f[i] == physical_entry.data.f[0]) { - physical_focal_length_map_[physical_entry.data.f[0]] = it.first; - break; - } - } - } - } + + for (const auto& one_zoom_range : zoom_ratio_physical_camera_info_) { + ALOGV("%s: cameraId %d, focalLength %f, zoomRatioRange [%f, %f]", + __FUNCTION__, one_zoom_range.physical_camera_id, + one_zoom_range.focal_length, one_zoom_range.min_zoom_ratio, + one_zoom_range.max_zoom_ratio); } - if (physical_focal_length_map_.size() > 1) { + if (zoom_ratio_physical_camera_info_.size() > 1) { is_logical_device_ = true; - current_focal_length_ = logical_entry.data.f[0]; for (const auto& it : *physical_device_map_) { std::unique_ptr<EmulatedRequestState> physical_request_state = std::make_unique<EmulatedRequestState>(it.first); @@ -103,8 +92,7 @@ EmulatedLogicalRequestState::InitializeLogicalResult(uint32_t pipeline_id, ->result_metadata); } } - auto physical_device_id = - std::to_string(physical_focal_length_map_[current_focal_length_]); + auto physical_device_id = std::to_string(current_physical_camera_); std::vector<uint8_t> result; result.reserve(physical_device_id.size() + 1); result.insert(result.end(), physical_device_id.begin(), @@ -163,21 +151,6 @@ status_t EmulatedLogicalRequestState::InitializeLogicalSettings( } } } - - camera_metadata_ro_entry entry; - auto stat = request_settings->Get(ANDROID_LENS_FOCAL_LENGTH, &entry); - if ((stat == OK) && (entry.count == 1)) { - if (physical_focal_length_map_.find(entry.data.f[0]) != - physical_focal_length_map_.end()) { - current_focal_length_ = entry.data.f[0]; - } else { - ALOGE("%s: Unsupported focal length set: %5.2f, re-using older value!", - __FUNCTION__, entry.data.f[0]); - } - } else { - ALOGW("%s: Focal length absent from request, re-using older value!", - __FUNCTION__); - } } EmulatedSensor::SensorSettings sensor_settings; @@ -209,42 +182,42 @@ EmulatedLogicalRequestState::AdaptLogicalCharacteristics( // physical devices with different focal lengths. Usually real logical // cameras like that will have device specific logic to switch between // physical sensors. Unfortunately we cannot infer this behavior using only - // static camera characteristics. Instead of this, detect the different - // focal lengths and update the logical - // "android.lens.info.availableFocalLengths" accordingly. + // static camera characteristics. Use a simplistic approach of inferring + // physical camera based on zoom ratio. + std::vector<ZoomRatioPhysicalCameraInfo> zoom_ratio_physical_camera_info = + GetZoomRatioPhysicalCameraInfo(logical_chars.get(), + physical_devices.get()); + std::vector<uint8_t> physical_ids; - std::set<float> focal_lengths; - camera_metadata_ro_entry_t entry; for (const auto& physical_device : *physical_devices) { auto physical_id = std::to_string(physical_device.first); physical_ids.insert(physical_ids.end(), physical_id.begin(), physical_id.end()); physical_ids.push_back('\0'); - auto ret = physical_device.second.second->Get( - ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS, &entry); - if ((ret == OK) && (entry.count > 0)) { - focal_lengths.insert(entry.data.f, entry.data.f + entry.count); - } } - logical_chars->Set(ANDROID_LOGICAL_MULTI_CAMERA_PHYSICAL_IDS, - physical_ids.data(), physical_ids.size()); - if (focal_lengths.size() > 1) { - std::vector<float> focal_buffer; - focal_buffer.reserve(focal_lengths.size()); - focal_buffer.insert(focal_buffer.end(), focal_lengths.begin(), - focal_lengths.end()); - logical_chars->Set(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS, - focal_buffer.data(), focal_buffer.size()); + if (zoom_ratio_physical_camera_info.size() > 1) { + float zoom_range[2]; + zoom_range[0] = zoom_ratio_physical_camera_info[0].min_zoom_ratio; + zoom_range[1] = + zoom_ratio_physical_camera_info[zoom_ratio_physical_camera_info.size() - 1] + .max_zoom_ratio; + logical_chars->Set(ANDROID_CONTROL_ZOOM_RATIO_RANGE, zoom_range, 2); + + logical_chars->Set(ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM, + &zoom_range[1], 1); + + logical_chars->Set(ANDROID_LOGICAL_MULTI_CAMERA_PHYSICAL_IDS, + physical_ids.data(), physical_ids.size()); // Possibly needs to be removed at some later point: int32_t default_physical_id = physical_devices->begin()->first; logical_chars->Set(google_camera_hal::kLogicalCamDefaultPhysicalId, &default_physical_id, 1); + camera_metadata_ro_entry entry; logical_chars->Get(ANDROID_REQUEST_AVAILABLE_RESULT_KEYS, &entry); std::set<int32_t> keys(entry.data.i32, entry.data.i32 + entry.count); - keys.emplace(ANDROID_LENS_FOCAL_LENGTH); keys.emplace(ANDROID_LOGICAL_MULTI_CAMERA_ACTIVE_PHYSICAL_ID); std::vector<int32_t> keys_buffer(keys.begin(), keys.end()); logical_chars->Set(ANDROID_REQUEST_AVAILABLE_RESULT_KEYS, @@ -257,23 +230,13 @@ EmulatedLogicalRequestState::AdaptLogicalCharacteristics( // Due to API limitations we currently don't support individual physical requests logical_chars->Erase(ANDROID_REQUEST_AVAILABLE_PHYSICAL_CAMERA_REQUEST_KEYS); keys.erase(ANDROID_REQUEST_AVAILABLE_PHYSICAL_CAMERA_REQUEST_KEYS); - keys.emplace(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS); keys.emplace(ANDROID_LOGICAL_MULTI_CAMERA_PHYSICAL_IDS); keys_buffer.insert(keys_buffer.end(), keys.begin(), keys.end()); logical_chars->Set(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS, keys_buffer.data(), keys_buffer.size()); - - keys.clear(); - keys_buffer.clear(); - logical_chars->Get(ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS, &entry); - keys.insert(entry.data.i32, entry.data.i32 + entry.count); - keys.emplace(ANDROID_LENS_FOCAL_LENGTH); - keys_buffer.insert(keys_buffer.end(), keys.begin(), keys.end()); - logical_chars->Set(ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS, - keys_buffer.data(), keys_buffer.size()); } else { ALOGW( - "%s: The logical camera doesn't support different focal lengths. " + "%s: The logical camera doesn't support combined zoom ratio ranges. " "Emulation " "could be" " very limited in this case!", @@ -302,19 +265,22 @@ status_t EmulatedLogicalRequestState::UpdateRequestForDynamicStreams( if (request->settings != nullptr) { camera_metadata_ro_entry entry; - auto stat = request->settings->Get(ANDROID_LENS_FOCAL_LENGTH, &entry); + auto stat = request->settings->Get(ANDROID_CONTROL_ZOOM_RATIO, &entry); if (stat != OK || entry.count != 1) { - ALOGW("%s: Focal length absent from request, re-using older value!", + ALOGW("%s: Zoom ratio absent from request, re-using older value!", __FUNCTION__); return BAD_VALUE; } - float focal_length = entry.data.f[0]; - if (physical_focal_length_map_.find(focal_length) == - physical_focal_length_map_.end()) { - ALOGW("%s: Invalid focal length %f", __FUNCTION__, focal_length); - return BAD_VALUE; + float zoom_ratio = entry.data.f[0]; + for (const auto& one_range : zoom_ratio_physical_camera_info_) { + if (zoom_ratio >= one_range.min_zoom_ratio && + zoom_ratio <= one_range.max_zoom_ratio) { + current_physical_camera_ = one_range.physical_camera_id; + ALOGV("%s: current_physical_camera_ is %d", __FUNCTION__, + current_physical_camera_); + break; + } } - active_physical_device_id_ = physical_focal_length_map_[focal_length]; } const auto& current_pipeline = pipelines[pipeline_id]; @@ -323,11 +289,11 @@ status_t EmulatedLogicalRequestState::UpdateRequestForDynamicStreams( if (current_stream.group_id == -1) continue; const auto& stream_ids_for_camera = - dynamic_stream_id_map.find(active_physical_device_id_); + dynamic_stream_id_map.find(current_physical_camera_); if (stream_ids_for_camera == dynamic_stream_id_map.end()) { ALOGW( "%s: Failed to find physical camera id %d in dynamic stream id map!", - __FUNCTION__, active_physical_device_id_); + __FUNCTION__, current_physical_camera_); continue; } const auto& stream_id = @@ -336,7 +302,7 @@ status_t EmulatedLogicalRequestState::UpdateRequestForDynamicStreams( ALOGW( "%s: Failed to find group id %d in dynamic stream id map for camera " "%d", - __FUNCTION__, current_stream.group_id, active_physical_device_id_); + __FUNCTION__, current_stream.group_id, current_physical_camera_); continue; } @@ -345,4 +311,75 @@ status_t EmulatedLogicalRequestState::UpdateRequestForDynamicStreams( return OK; } +std::vector<ZoomRatioPhysicalCameraInfo> +EmulatedLogicalRequestState::GetZoomRatioPhysicalCameraInfo( + const HalCameraMetadata* logical_chars, + const PhysicalDeviceMap* physical_devices) { + std::vector<ZoomRatioPhysicalCameraInfo> zoom_ratio_physical_camera_info; + if ((logical_chars == nullptr) || (physical_devices == nullptr)) { + return zoom_ratio_physical_camera_info; + } + + // Get the logical camera's focal length and sensor size + camera_metadata_ro_entry_t entry; + auto ret = + logical_chars->Get(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS, &entry); + if ((ret != OK) || (entry.count == 0)) { + return zoom_ratio_physical_camera_info; + } + float logical_focal_length = entry.data.f[0]; + ret = logical_chars->Get(ANDROID_SENSOR_INFO_PHYSICAL_SIZE, &entry); + if ((ret != OK) || (entry.count == 0)) { + return zoom_ratio_physical_camera_info; + } + float logical_sensor_width = entry.data.f[0]; + + // Derive the zoom ratio boundary values for each physical camera id, based on + // focal lengths and camera sensor physical size. + for (const auto& physical_device : *physical_devices) { + ret = physical_device.second.second->Get( + ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS, &entry); + if ((ret == OK) && (entry.count > 0)) { + float focal_length = entry.data.f[0]; + ret = physical_device.second.second->Get( + ANDROID_SENSOR_INFO_PHYSICAL_SIZE, &entry); + if ((ret == OK) && (entry.count > 0)) { + float sensor_width = entry.data.f[0]; + ret = physical_device.second.second->Get( + ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM, &entry); + if ((ret == OK) && (entry.count > 0)) { + float max_digital_zoom = entry.data.f[0]; + // focal length of ultrawide lens + float min_zoom_ratio = focal_length * logical_sensor_width / + (logical_focal_length * sensor_width); + float max_zoom_ratio = max_digital_zoom * min_zoom_ratio; + zoom_ratio_physical_camera_info.push_back( + {focal_length, min_zoom_ratio, max_zoom_ratio, + physical_device.first}); + } + } + } + } + + // Sort the mapping by ascending focal length + std::sort(zoom_ratio_physical_camera_info.begin(), + zoom_ratio_physical_camera_info.end(), + [](const ZoomRatioPhysicalCameraInfo& a, + const ZoomRatioPhysicalCameraInfo& b) { + return a.focal_length < b.focal_length; + }); + + // Modify the zoom ratio range for each focal length so that they don't + // overlap + for (size_t i = 0; i < zoom_ratio_physical_camera_info.size() - 1; i++) { + auto& current = zoom_ratio_physical_camera_info[i]; + auto& next = zoom_ratio_physical_camera_info[i + 1]; + if (current.max_zoom_ratio > next.min_zoom_ratio) { + current.max_zoom_ratio = next.min_zoom_ratio; + } + } + + return zoom_ratio_physical_camera_info; +} + } // namespace android diff --git a/devices/EmulatedCamera/hwl/EmulatedLogicalRequestState.h b/devices/EmulatedCamera/hwl/EmulatedLogicalRequestState.h index ad515d3..091d41a 100644 --- a/devices/EmulatedCamera/hwl/EmulatedLogicalRequestState.h +++ b/devices/EmulatedCamera/hwl/EmulatedLogicalRequestState.h @@ -44,6 +44,15 @@ struct EmulatedPipeline { // [physical_camera_id -> [group_id -> stream_id]] typedef std::map<uint32_t, std::map<uint32_t, int32_t>> DynamicStreamIdMapType; +// Info keeping track of mapping between zoom ratio range, focal length, and +// physical camera Id. +struct ZoomRatioPhysicalCameraInfo { + float focal_length; + float min_zoom_ratio; + float max_zoom_ratio; + uint32_t physical_camera_id; +}; + class EmulatedLogicalRequestState { public: EmulatedLogicalRequestState(uint32_t camera_id); @@ -77,15 +86,20 @@ class EmulatedLogicalRequestState { uint32_t logical_camera_id_ = 0; std::unique_ptr<EmulatedRequestState> logical_request_state_; bool is_logical_device_ = false; - uint32_t active_physical_device_id_ = 0; std::unique_ptr<std::set<uint32_t>> physical_camera_output_ids_; PhysicalDeviceMapPtr physical_device_map_; // Maps a physical device id to its respective request state std::unordered_map<uint32_t, std::unique_ptr<EmulatedRequestState>> physical_request_states_; - // Maps particular focal length to physical device id - std::unordered_map<float, uint32_t> physical_focal_length_map_; - float current_focal_length_ = 0.f; + + // Describes the mapping between particular zoom ratio boundary value and + // physical device id. The vector is sorted by ascending zoom ratios. + std::vector<ZoomRatioPhysicalCameraInfo> zoom_ratio_physical_camera_info_; + uint32_t current_physical_camera_ = 0; + + static std::vector<ZoomRatioPhysicalCameraInfo> GetZoomRatioPhysicalCameraInfo( + const HalCameraMetadata* logical_chars, + const PhysicalDeviceMap* physical_devices); EmulatedLogicalRequestState(const EmulatedLogicalRequestState&) = delete; EmulatedLogicalRequestState& operator=(const EmulatedLogicalRequestState&) = diff --git a/devices/EmulatedCamera/hwl/EmulatedRequestProcessor.cpp b/devices/EmulatedCamera/hwl/EmulatedRequestProcessor.cpp index 9b4e2a4..dd2321e 100644 --- a/devices/EmulatedCamera/hwl/EmulatedRequestProcessor.cpp +++ b/devices/EmulatedCamera/hwl/EmulatedRequestProcessor.cpp @@ -95,11 +95,17 @@ status_t EmulatedRequestProcessor::ProcessPipelineRequests( auto output_buffers = CreateSensorBuffers( frame_number, request.output_buffers, pipelines[request.pipeline_id].streams, request.pipeline_id, - pipelines[request.pipeline_id].cb); + pipelines[request.pipeline_id].cb, /*override_width*/ 0, + /*override_height*/ 0); + if (output_buffers == nullptr) { + return NO_MEMORY; + } + auto input_buffers = CreateSensorBuffers( frame_number, request.input_buffers, pipelines[request.pipeline_id].streams, request.pipeline_id, - pipelines[request.pipeline_id].cb); + pipelines[request.pipeline_id].cb, request.input_width, + request.input_height); pending_requests_.push( {.settings = HalCameraMetadata::Clone(request.settings.get()), @@ -113,7 +119,8 @@ status_t EmulatedRequestProcessor::ProcessPipelineRequests( std::unique_ptr<Buffers> EmulatedRequestProcessor::CreateSensorBuffers( uint32_t frame_number, const std::vector<StreamBuffer>& buffers, const std::unordered_map<uint32_t, EmulatedStream>& streams, - uint32_t pipeline_id, HwlPipelineCallback cb) { + uint32_t pipeline_id, HwlPipelineCallback cb, int32_t override_width, + int32_t override_height) { if (buffers.empty()) { return nullptr; } @@ -144,8 +151,14 @@ std::unique_ptr<Buffers> EmulatedRequestProcessor::CreateSensorBuffers( } } - if (requested_buffers.size() == 0) { - ALOGE("%s: Failed to acquire sensor buffers", __FUNCTION__); + if (requested_buffers.size() < buffers.size()) { + ALOGE( + "%s: Failed to acquire all sensor buffers: %zu acquired, %zu requested", + __FUNCTION__, requested_buffers.size(), buffers.size()); + // This only happens for HAL buffer manager use case. + if (session_callback_.return_stream_buffers != nullptr) { + session_callback_.return_stream_buffers(requested_buffers); + } return nullptr; } @@ -153,7 +166,8 @@ std::unique_ptr<Buffers> EmulatedRequestProcessor::CreateSensorBuffers( sensor_buffers->reserve(requested_buffers.size()); for (auto& buffer : requested_buffers) { auto sensor_buffer = CreateSensorBuffer( - frame_number, streams.at(buffer.stream_id), pipeline_id, cb, buffer); + frame_number, streams.at(buffer.stream_id), pipeline_id, cb, buffer, + override_width, override_height); if (sensor_buffer.get() != nullptr) { sensor_buffers->push_back(std::move(sensor_buffer)); } @@ -240,14 +254,12 @@ status_t EmulatedRequestProcessor::GetBufferSizeAndStride( } status_t EmulatedRequestProcessor::LockSensorBuffer( - const EmulatedStream& stream, buffer_handle_t buffer, - SensorBuffer* sensor_buffer /*out*/) { + const EmulatedStream& stream, buffer_handle_t buffer, int32_t width, + int32_t height, SensorBuffer* sensor_buffer /*out*/) { if (sensor_buffer == nullptr) { return BAD_VALUE; } - auto width = static_cast<int32_t>(stream.width); - auto height = static_cast<int32_t>(stream.height); auto usage = GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN; bool isYUV_420_888 = stream.override_format == HAL_PIXEL_FORMAT_YCBCR_420_888; bool isP010 = static_cast<android_pixel_format_v1_1_t>( @@ -311,7 +323,8 @@ status_t EmulatedRequestProcessor::LockSensorBuffer( std::unique_ptr<SensorBuffer> EmulatedRequestProcessor::CreateSensorBuffer( uint32_t frame_number, const EmulatedStream& emulated_stream, uint32_t pipeline_id, HwlPipelineCallback callback, - StreamBuffer stream_buffer) { + StreamBuffer stream_buffer, int32_t override_width, + int32_t override_height) { auto buffer = std::make_unique<SensorBuffer>(importer_); auto stream = emulated_stream; @@ -320,8 +333,13 @@ std::unique_ptr<SensorBuffer> EmulatedRequestProcessor::CreateSensorBuffer( stream.override_format = EmulatedSensor::OverrideFormat(stream.override_format); } - buffer->width = stream.width; - buffer->height = stream.height; + if (override_width > 0 && override_height > 0) { + buffer->width = override_width; + buffer->height = override_height; + } else { + buffer->width = stream.width; + buffer->height = stream.height; + } buffer->format = static_cast<PixelFormat>(stream.override_format); buffer->dataSpace = stream.override_data_space; buffer->stream_buffer = stream_buffer; @@ -336,8 +354,8 @@ std::unique_ptr<SensorBuffer> EmulatedRequestProcessor::CreateSensorBuffer( buffer->stream_buffer.status = BufferStatus::kError; if (buffer->stream_buffer.buffer != nullptr) { - auto ret = - LockSensorBuffer(stream, buffer->stream_buffer.buffer, buffer.get()); + auto ret = LockSensorBuffer(stream, buffer->stream_buffer.buffer, + buffer->width, buffer->height, buffer.get()); if (ret != OK) { buffer.release(); buffer = nullptr; diff --git a/devices/EmulatedCamera/hwl/EmulatedRequestProcessor.h b/devices/EmulatedCamera/hwl/EmulatedRequestProcessor.h index 957435d..d6e0af5 100644 --- a/devices/EmulatedCamera/hwl/EmulatedRequestProcessor.h +++ b/devices/EmulatedCamera/hwl/EmulatedRequestProcessor.h @@ -80,17 +80,17 @@ class EmulatedRequestProcessor { uint32_t* size /*out*/, uint32_t* stride /*out*/); status_t LockSensorBuffer(const EmulatedStream& stream, - buffer_handle_t buffer, - SensorBuffer* sensor_buffer /*out*/); + buffer_handle_t buffer, int32_t width, + int32_t height, SensorBuffer* sensor_buffer /*out*/); std::unique_ptr<Buffers> CreateSensorBuffers( uint32_t frame_number, const std::vector<StreamBuffer>& buffers, const std::unordered_map<uint32_t, EmulatedStream>& streams, - uint32_t pipeline_id, HwlPipelineCallback cb); - std::unique_ptr<SensorBuffer> CreateSensorBuffer(uint32_t frame_number, - const EmulatedStream& stream, - uint32_t pipeline_id, - HwlPipelineCallback callback, - StreamBuffer stream_buffer); + uint32_t pipeline_id, HwlPipelineCallback cb, int32_t override_width, + int32_t override_height); + std::unique_ptr<SensorBuffer> CreateSensorBuffer( + uint32_t frame_number, const EmulatedStream& stream, uint32_t pipeline_id, + HwlPipelineCallback callback, StreamBuffer stream_buffer, + int32_t override_width, int32_t override_height); std::unique_ptr<Buffers> AcquireBuffers(Buffers* buffers); void NotifyFailedRequest(const PendingRequest& request); diff --git a/devices/EmulatedCamera/hwl/EmulatedRequestState.cpp b/devices/EmulatedCamera/hwl/EmulatedRequestState.cpp index 724c92b..0b01bb7 100644 --- a/devices/EmulatedCamera/hwl/EmulatedRequestState.cpp +++ b/devices/EmulatedCamera/hwl/EmulatedRequestState.cpp @@ -1802,7 +1802,8 @@ status_t EmulatedRequestState::InitializeControlDefaults() { float min_zoom_ratio, max_zoom_ratio; if (mode < ANDROID_CONTROL_EXTENDED_SCENE_MODE_DISABLED || - mode > ANDROID_CONTROL_EXTENDED_SCENE_MODE_BOKEH_CONTINUOUS) { + (mode > ANDROID_CONTROL_EXTENDED_SCENE_MODE_BOKEH_CONTINUOUS && + mode < ANDROID_CONTROL_EXTENDED_SCENE_MODE_VENDOR_START)) { ALOGE("%s: Invalid extended scene mode %d", __FUNCTION__, mode); return BAD_VALUE; } diff --git a/devices/EmulatedCamera/hwl/configs/emu_camera_back.json b/devices/EmulatedCamera/hwl/configs/emu_camera_back.json index dc656ea..0a647d9 100644 --- a/devices/EmulatedCamera/hwl/configs/emu_camera_back.json +++ b/devices/EmulatedCamera/hwl/configs/emu_camera_back.json @@ -48,11 +48,16 @@ "0", "1", "1856", + "1392", + "64", + "1856", "1392" ], "android.control.availableExtendedSceneModeZoomRatioRanges": [ "1.0", - "4.0" + "4.0", + "1.0", + "4.0" ], "android.control.availableEffects": [ "0" |