1 /* 2 * Copyright (C) 2013 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 /** 18 * Contains implementation of a class EmulatedCamera that encapsulates 19 * functionality common to all version 3.0 emulated camera devices. Instances 20 * of this class (for each emulated camera) are created during the construction 21 * of the EmulatedCameraFactory instance. This class serves as an entry point 22 * for all camera API calls that defined by camera3_device_ops_t API. 23 */ 24 25 //#define LOG_NDEBUG 0 26 #define LOG_TAG "EmulatedCamera3_Camera" 27 #include <cutils/log.h> 28 29 #include "EmulatedCamera3.h" 30 #include "system/camera_metadata.h" 31 32 namespace android { 33 34 /** 35 * Constructs EmulatedCamera3 instance. 36 * Param: 37 * cameraId - Zero based camera identifier, which is an index of the camera 38 * instance in camera factory's array. 39 * module - Emulated camera HAL module descriptor. 40 */ 41 EmulatedCamera3::EmulatedCamera3(int cameraId, 42 struct hw_module_t* module): 43 EmulatedBaseCamera(cameraId, 44 CAMERA_DEVICE_API_VERSION_3_3, 45 &common, 46 module), 47 mStatus(STATUS_ERROR) 48 { 49 common.close = EmulatedCamera3::close; 50 ops = &sDeviceOps; 51 52 mCallbackOps = NULL; 53 54 } 55 56 /* Destructs EmulatedCamera3 instance. */ 57 EmulatedCamera3::~EmulatedCamera3() { 58 } 59 60 /**************************************************************************** 61 * Abstract API 62 ***************************************************************************/ 63 64 /**************************************************************************** 65 * Public API 66 ***************************************************************************/ 67 68 status_t EmulatedCamera3::Initialize() { 69 ALOGV("%s", __FUNCTION__); 70 71 mStatus = STATUS_CLOSED; 72 return NO_ERROR; 73 } 74 75 /**************************************************************************** 76 * Camera API implementation 77 ***************************************************************************/ 78 79 status_t EmulatedCamera3::connectCamera(hw_device_t** device) { 80 ALOGV("%s", __FUNCTION__); 81 if (device == NULL) return BAD_VALUE; 82 83 if (mStatus != STATUS_CLOSED) { 84 ALOGE("%s: Trying to open a camera in state %d!", 85 __FUNCTION__, mStatus); 86 return INVALID_OPERATION; 87 } 88 89 *device = &common; 90 mStatus = STATUS_OPEN; 91 return NO_ERROR; 92 } 93 94 status_t EmulatedCamera3::closeCamera() { 95 mStatus = STATUS_CLOSED; 96 return NO_ERROR; 97 } 98 99 status_t EmulatedCamera3::getCameraInfo(struct camera_info* info) { 100 return EmulatedBaseCamera::getCameraInfo(info); 101 } 102 103 /**************************************************************************** 104 * Camera Device API implementation. 105 * These methods are called from the camera API callback routines. 106 ***************************************************************************/ 107 108 status_t EmulatedCamera3::initializeDevice( 109 const camera3_callback_ops *callbackOps) { 110 if (callbackOps == NULL) { 111 ALOGE("%s: NULL callback ops provided to HAL!", 112 __FUNCTION__); 113 return BAD_VALUE; 114 } 115 116 if (mStatus != STATUS_OPEN) { 117 ALOGE("%s: Trying to initialize a camera in state %d!", 118 __FUNCTION__, mStatus); 119 return INVALID_OPERATION; 120 } 121 122 mCallbackOps = callbackOps; 123 mStatus = STATUS_READY; 124 125 return NO_ERROR; 126 } 127 128 status_t EmulatedCamera3::configureStreams( 129 camera3_stream_configuration *streamList) { 130 ALOGE("%s: Not implemented", __FUNCTION__); 131 return INVALID_OPERATION; 132 } 133 134 status_t EmulatedCamera3::registerStreamBuffers( 135 const camera3_stream_buffer_set *bufferSet) { 136 ALOGE("%s: Not implemented", __FUNCTION__); 137 return INVALID_OPERATION; 138 } 139 140 const camera_metadata_t* EmulatedCamera3::constructDefaultRequestSettings( 141 int type) { 142 ALOGE("%s: Not implemented", __FUNCTION__); 143 return NULL; 144 } 145 146 status_t EmulatedCamera3::processCaptureRequest( 147 camera3_capture_request *request) { 148 ALOGE("%s: Not implemented", __FUNCTION__); 149 return INVALID_OPERATION; 150 } 151 152 status_t EmulatedCamera3::flush() { 153 ALOGE("%s: Not implemented", __FUNCTION__); 154 return INVALID_OPERATION; 155 } 156 157 /** Debug methods */ 158 159 void EmulatedCamera3::dump(int fd) { 160 ALOGE("%s: Not implemented", __FUNCTION__); 161 return; 162 } 163 164 /**************************************************************************** 165 * Protected API. Callbacks to the framework. 166 ***************************************************************************/ 167 168 void EmulatedCamera3::sendCaptureResult(camera3_capture_result_t *result) { 169 mCallbackOps->process_capture_result(mCallbackOps, result); 170 } 171 172 void EmulatedCamera3::sendNotify(camera3_notify_msg_t *msg) { 173 mCallbackOps->notify(mCallbackOps, msg); 174 } 175 176 /**************************************************************************** 177 * Private API. 178 ***************************************************************************/ 179 180 /**************************************************************************** 181 * Camera API callbacks as defined by camera3_device_ops structure. See 182 * hardware/libhardware/include/hardware/camera3.h for information on each 183 * of these callbacks. Implemented in this class, these callbacks simply 184 * dispatch the call into an instance of EmulatedCamera3 class defined by the 185 * 'camera_device3' parameter, or set a member value in the same. 186 ***************************************************************************/ 187 188 EmulatedCamera3* getInstance(const camera3_device_t *d) { 189 const EmulatedCamera3* cec = static_cast<const EmulatedCamera3*>(d); 190 return const_cast<EmulatedCamera3*>(cec); 191 } 192 193 int EmulatedCamera3::initialize(const struct camera3_device *d, 194 const camera3_callback_ops_t *callback_ops) { 195 EmulatedCamera3* ec = getInstance(d); 196 return ec->initializeDevice(callback_ops); 197 } 198 199 int EmulatedCamera3::configure_streams(const struct camera3_device *d, 200 camera3_stream_configuration_t *stream_list) { 201 EmulatedCamera3* ec = getInstance(d); 202 return ec->configureStreams(stream_list); 203 } 204 205 int EmulatedCamera3::register_stream_buffers( 206 const struct camera3_device *d, 207 const camera3_stream_buffer_set_t *buffer_set) { 208 EmulatedCamera3* ec = getInstance(d); 209 return ec->registerStreamBuffers(buffer_set); 210 } 211 212 int EmulatedCamera3::process_capture_request( 213 const struct camera3_device *d, 214 camera3_capture_request_t *request) { 215 EmulatedCamera3* ec = getInstance(d); 216 return ec->processCaptureRequest(request); 217 } 218 219 const camera_metadata_t* EmulatedCamera3::construct_default_request_settings( 220 const camera3_device_t *d, int type) { 221 EmulatedCamera3* ec = getInstance(d); 222 return ec->constructDefaultRequestSettings(type); 223 } 224 225 void EmulatedCamera3::dump(const camera3_device_t *d, int fd) { 226 EmulatedCamera3* ec = getInstance(d); 227 ec->dump(fd); 228 } 229 230 int EmulatedCamera3::flush(const camera3_device_t *d) { 231 EmulatedCamera3* ec = getInstance(d); 232 return ec->flush(); 233 } 234 235 int EmulatedCamera3::close(struct hw_device_t* device) { 236 EmulatedCamera3* ec = 237 static_cast<EmulatedCamera3*>( 238 reinterpret_cast<camera3_device_t*>(device) ); 239 if (ec == NULL) { 240 ALOGE("%s: Unexpected NULL camera3 device", __FUNCTION__); 241 return BAD_VALUE; 242 } 243 return ec->closeCamera(); 244 } 245 246 camera3_device_ops_t EmulatedCamera3::sDeviceOps = { 247 EmulatedCamera3::initialize, 248 EmulatedCamera3::configure_streams, 249 /* DEPRECATED: register_stream_buffers */ nullptr, 250 EmulatedCamera3::construct_default_request_settings, 251 EmulatedCamera3::process_capture_request, 252 /* DEPRECATED: get_metadata_vendor_tag_ops */ nullptr, 253 EmulatedCamera3::dump, 254 EmulatedCamera3::flush 255 }; 256 257 const char* EmulatedCamera3::sAvailableCapabilitiesStrings[NUM_CAPABILITIES] = { 258 "BACKWARD_COMPATIBLE", 259 "MANUAL_SENSOR", 260 "MANUAL_POST_PROCESSING", 261 "RAW", 262 "PRIVATE_REPROCESSING", 263 "READ_SENSOR_SETTINGS", 264 "BURST_CAPTURE", 265 "YUV_REPROCESSING", 266 "DEPTH_OUTPUT", 267 "CONSTRAINED_HIGH_SPEED_VIDEO", 268 "FULL_LEVEL" 269 }; 270 271 }; /* namespace android */ 272
