1 /* Copyright (c) 2012-2015, The Linux Foundataion. All rights reserved.
2 *
3 * Redistribution and use in source and binary forms, with or without
4 * modification, are permitted provided that the following conditions are
5 * met:
6 * * Redistributions of source code must retain the above copyright
7 * notice, this list of conditions and the following disclaimer.
8 * * Redistributions in binary form must reproduce the above
9 * copyright notice, this list of conditions and the following
10 * disclaimer in the documentation and/or other materials provided
11 * with the distribution.
12 * * Neither the name of The Linux Foundation nor the names of its
13 * contributors may be used to endorse or promote products derived
14 * from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
23 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
24 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
25 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
26 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 */
29
30 #define ATRACE_TAG ATRACE_TAG_CAMERA
31 #define LOG_TAG "QCamera3HWI"
32 //#define LOG_NDEBUG 0
33
34 #define __STDC_LIMIT_MACROS
35 #include <cutils/properties.h>
36 #include <hardware/camera3.h>
37 #include <camera/CameraMetadata.h>
38 #include <stdio.h>
39 #include <stdlib.h>
40 #include <fcntl.h>
41 #include <stdint.h>
42 #include <utils/Log.h>
43 #include <utils/Errors.h>
44 #include <utils/Trace.h>
45 #include <sync/sync.h>
46 #include <gralloc_priv.h>
47 #include "util/QCameraFlash.h"
48 #include "QCamera3HWI.h"
49 #include "QCamera3Mem.h"
50 #include "QCamera3Channel.h"
51 #include "QCamera3PostProc.h"
52 #include "QCamera3VendorTags.h"
53
54 using namespace android;
55
56 namespace qcamera {
57
58 #define DATA_PTR(MEM_OBJ,INDEX) MEM_OBJ->getPtr( INDEX )
59
60 #define EMPTY_PIPELINE_DELAY 2
61 #define PARTIAL_RESULT_COUNT 2
62 #define FRAME_SKIP_DELAY 0
63 #define CAM_MAX_SYNC_LATENCY 4
64
65 #define VIDEO_4K_WIDTH 3840
66 #define VIDEO_4K_HEIGHT 2160
67
68 #define MAX_RAW_STREAMS 1
69 #define MAX_STALLING_STREAMS 1
70 #define MAX_PROCESSED_STREAMS 3
71 #define TIMEOUT_NEVER -1
72
73 cam_capability_t *gCamCapability[MM_CAMERA_MAX_NUM_SENSORS];
74 const camera_metadata_t *gStaticMetadata[MM_CAMERA_MAX_NUM_SENSORS];
75 volatile uint32_t gCamHal3LogLevel = 1;
76
77 const QCamera3HardwareInterface::QCameraPropMap QCamera3HardwareInterface::CDS_MAP [] = {
78 {"On", CAM_CDS_MODE_ON},
79 {"Off", CAM_CDS_MODE_OFF},
80 {"Auto",CAM_CDS_MODE_AUTO}
81 };
82
83 const QCamera3HardwareInterface::QCameraMap QCamera3HardwareInterface::EFFECT_MODES_MAP[] = {
84 { ANDROID_CONTROL_EFFECT_MODE_OFF, CAM_EFFECT_MODE_OFF },
85 { ANDROID_CONTROL_EFFECT_MODE_MONO, CAM_EFFECT_MODE_MONO },
86 { ANDROID_CONTROL_EFFECT_MODE_NEGATIVE, CAM_EFFECT_MODE_NEGATIVE },
87 { ANDROID_CONTROL_EFFECT_MODE_SOLARIZE, CAM_EFFECT_MODE_SOLARIZE },
88 { ANDROID_CONTROL_EFFECT_MODE_SEPIA, CAM_EFFECT_MODE_SEPIA },
89 { ANDROID_CONTROL_EFFECT_MODE_POSTERIZE, CAM_EFFECT_MODE_POSTERIZE },
90 { ANDROID_CONTROL_EFFECT_MODE_WHITEBOARD, CAM_EFFECT_MODE_WHITEBOARD },
91 { ANDROID_CONTROL_EFFECT_MODE_BLACKBOARD, CAM_EFFECT_MODE_BLACKBOARD },
92 { ANDROID_CONTROL_EFFECT_MODE_AQUA, CAM_EFFECT_MODE_AQUA }
93 };
94
95 const QCamera3HardwareInterface::QCameraMap QCamera3HardwareInterface::WHITE_BALANCE_MODES_MAP[] = {
96 { ANDROID_CONTROL_AWB_MODE_OFF, CAM_WB_MODE_OFF },
97 { ANDROID_CONTROL_AWB_MODE_AUTO, CAM_WB_MODE_AUTO },
98 { ANDROID_CONTROL_AWB_MODE_INCANDESCENT, CAM_WB_MODE_INCANDESCENT },
99 { ANDROID_CONTROL_AWB_MODE_FLUORESCENT, CAM_WB_MODE_FLUORESCENT },
100 { ANDROID_CONTROL_AWB_MODE_WARM_FLUORESCENT,CAM_WB_MODE_WARM_FLUORESCENT},
101 { ANDROID_CONTROL_AWB_MODE_DAYLIGHT, CAM_WB_MODE_DAYLIGHT },
102 { ANDROID_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT, CAM_WB_MODE_CLOUDY_DAYLIGHT },
103 { ANDROID_CONTROL_AWB_MODE_TWILIGHT, CAM_WB_MODE_TWILIGHT },
104 { ANDROID_CONTROL_AWB_MODE_SHADE, CAM_WB_MODE_SHADE }
105 };
106
107 const QCamera3HardwareInterface::QCameraMap QCamera3HardwareInterface::SCENE_MODES_MAP[] = {
108 { ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY, CAM_SCENE_MODE_FACE_PRIORITY },
109 { ANDROID_CONTROL_SCENE_MODE_ACTION, CAM_SCENE_MODE_ACTION },
110 { ANDROID_CONTROL_SCENE_MODE_PORTRAIT, CAM_SCENE_MODE_PORTRAIT },
111 { ANDROID_CONTROL_SCENE_MODE_LANDSCAPE, CAM_SCENE_MODE_LANDSCAPE },
112 { ANDROID_CONTROL_SCENE_MODE_NIGHT, CAM_SCENE_MODE_NIGHT },
113 { ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT, CAM_SCENE_MODE_NIGHT_PORTRAIT },
114 { ANDROID_CONTROL_SCENE_MODE_THEATRE, CAM_SCENE_MODE_THEATRE },
115 { ANDROID_CONTROL_SCENE_MODE_BEACH, CAM_SCENE_MODE_BEACH },
116 { ANDROID_CONTROL_SCENE_MODE_SNOW, CAM_SCENE_MODE_SNOW },
117 { ANDROID_CONTROL_SCENE_MODE_SUNSET, CAM_SCENE_MODE_SUNSET },
118 { ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO, CAM_SCENE_MODE_ANTISHAKE },
119 { ANDROID_CONTROL_SCENE_MODE_FIREWORKS , CAM_SCENE_MODE_FIREWORKS },
120 { ANDROID_CONTROL_SCENE_MODE_SPORTS , CAM_SCENE_MODE_SPORTS },
121 { ANDROID_CONTROL_SCENE_MODE_PARTY, CAM_SCENE_MODE_PARTY },
122 { ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT, CAM_SCENE_MODE_CANDLELIGHT },
123 { ANDROID_CONTROL_SCENE_MODE_BARCODE, CAM_SCENE_MODE_BARCODE}
124 };
125
126 const QCamera3HardwareInterface::QCameraMap QCamera3HardwareInterface::FOCUS_MODES_MAP[] = {
127 { ANDROID_CONTROL_AF_MODE_OFF, CAM_FOCUS_MODE_OFF },
128 { ANDROID_CONTROL_AF_MODE_OFF, CAM_FOCUS_MODE_FIXED },
129 { ANDROID_CONTROL_AF_MODE_AUTO, CAM_FOCUS_MODE_AUTO },
130 { ANDROID_CONTROL_AF_MODE_MACRO, CAM_FOCUS_MODE_MACRO },
131 { ANDROID_CONTROL_AF_MODE_EDOF, CAM_FOCUS_MODE_EDOF },
132 { ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE, CAM_FOCUS_MODE_CONTINOUS_PICTURE },
133 { ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO, CAM_FOCUS_MODE_CONTINOUS_VIDEO }
134 };
135
136 const QCamera3HardwareInterface::QCameraMap QCamera3HardwareInterface::COLOR_ABERRATION_MAP[] = {
137 { ANDROID_COLOR_CORRECTION_ABERRATION_MODE_OFF,
138 CAM_COLOR_CORRECTION_ABERRATION_OFF },
139 { ANDROID_COLOR_CORRECTION_ABERRATION_MODE_FAST,
140 CAM_COLOR_CORRECTION_ABERRATION_FAST },
141 { ANDROID_COLOR_CORRECTION_ABERRATION_MODE_HIGH_QUALITY,
142 CAM_COLOR_CORRECTION_ABERRATION_HIGH_QUALITY },
143 };
144
145 const QCamera3HardwareInterface::QCameraMap QCamera3HardwareInterface::ANTIBANDING_MODES_MAP[] = {
146 { ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF, CAM_ANTIBANDING_MODE_OFF },
147 { ANDROID_CONTROL_AE_ANTIBANDING_MODE_50HZ, CAM_ANTIBANDING_MODE_50HZ },
148 { ANDROID_CONTROL_AE_ANTIBANDING_MODE_60HZ, CAM_ANTIBANDING_MODE_60HZ },
149 { ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO, CAM_ANTIBANDING_MODE_AUTO }
150 };
151
152 const QCamera3HardwareInterface::QCameraMap QCamera3HardwareInterface::AE_FLASH_MODE_MAP[] = {
153 { ANDROID_CONTROL_AE_MODE_OFF, CAM_FLASH_MODE_OFF },
154 { ANDROID_CONTROL_AE_MODE_ON, CAM_FLASH_MODE_OFF },
155 { ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH, CAM_FLASH_MODE_AUTO},
156 { ANDROID_CONTROL_AE_MODE_ON_ALWAYS_FLASH, CAM_FLASH_MODE_ON },
157 { ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE, CAM_FLASH_MODE_AUTO}
158 };
159
160 const QCamera3HardwareInterface::QCameraMap QCamera3HardwareInterface::FLASH_MODES_MAP[] = {
161 { ANDROID_FLASH_MODE_OFF, CAM_FLASH_MODE_OFF },
162 { ANDROID_FLASH_MODE_SINGLE, CAM_FLASH_MODE_SINGLE },
163 { ANDROID_FLASH_MODE_TORCH, CAM_FLASH_MODE_TORCH }
164 };
165
166 const QCamera3HardwareInterface::QCameraMap QCamera3HardwareInterface::FACEDETECT_MODES_MAP[] = {
167 { ANDROID_STATISTICS_FACE_DETECT_MODE_OFF, CAM_FACE_DETECT_MODE_OFF },
168 { ANDROID_STATISTICS_FACE_DETECT_MODE_FULL, CAM_FACE_DETECT_MODE_FULL }
169 };
170
171 const QCamera3HardwareInterface::QCameraMap QCamera3HardwareInterface::FOCUS_CALIBRATION_MAP[] = {
172 { ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION_UNCALIBRATED,
173 CAM_FOCUS_UNCALIBRATED },
174 { ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION_APPROXIMATE,
175 CAM_FOCUS_APPROXIMATE },
176 { ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION_CALIBRATED,
177 CAM_FOCUS_CALIBRATED }
178 };
179
180 const int32_t available_thumbnail_sizes[] = {0, 0,
181 176, 144,
182 320, 240,
183 432, 288,
184 480, 288,
185 512, 288,
186 512, 384};
187
188 const QCamera3HardwareInterface::QCameraMap QCamera3HardwareInterface::TEST_PATTERN_MAP[] = {
189 { ANDROID_SENSOR_TEST_PATTERN_MODE_OFF, CAM_TEST_PATTERN_OFF },
190 { ANDROID_SENSOR_TEST_PATTERN_MODE_SOLID_COLOR, CAM_TEST_PATTERN_SOLID_COLOR },
191 { ANDROID_SENSOR_TEST_PATTERN_MODE_COLOR_BARS, CAM_TEST_PATTERN_COLOR_BARS },
192 { ANDROID_SENSOR_TEST_PATTERN_MODE_COLOR_BARS_FADE_TO_GRAY, CAM_TEST_PATTERN_COLOR_BARS_FADE_TO_GRAY },
193 { ANDROID_SENSOR_TEST_PATTERN_MODE_PN9, CAM_TEST_PATTERN_PN9 },
194 };
195
196 /* Since there is no mapping for all the options some Android enum are not listed.
197 * Also, the order in this list is important because while mapping from HAL to Android it will
198 * traverse from lower to higher index which means that for HAL values that are map to different
199 * Android values, the traverse logic will select the first one found.
200 */
201 const QCamera3HardwareInterface::QCameraMap QCamera3HardwareInterface::REFERENCE_ILLUMINANT_MAP[] = {
202 { ANDROID_SENSOR_REFERENCE_ILLUMINANT1_FLUORESCENT, CAM_AWB_WARM_FLO},
203 { ANDROID_SENSOR_REFERENCE_ILLUMINANT1_DAYLIGHT_FLUORESCENT, CAM_AWB_CUSTOM_DAYLIGHT },
204 { ANDROID_SENSOR_REFERENCE_ILLUMINANT1_COOL_WHITE_FLUORESCENT, CAM_AWB_COLD_FLO },
205 { ANDROID_SENSOR_REFERENCE_ILLUMINANT1_STANDARD_A, CAM_AWB_A },
206 { ANDROID_SENSOR_REFERENCE_ILLUMINANT1_D55, CAM_AWB_NOON },
207 { ANDROID_SENSOR_REFERENCE_ILLUMINANT1_D65, CAM_AWB_D65 },
208 { ANDROID_SENSOR_REFERENCE_ILLUMINANT1_D75, CAM_AWB_D75 },
209 { ANDROID_SENSOR_REFERENCE_ILLUMINANT1_D50, CAM_AWB_D50 },
210 { ANDROID_SENSOR_REFERENCE_ILLUMINANT1_ISO_STUDIO_TUNGSTEN, CAM_AWB_CUSTOM_A},
211 { ANDROID_SENSOR_REFERENCE_ILLUMINANT1_DAYLIGHT, CAM_AWB_D50 },
212 { ANDROID_SENSOR_REFERENCE_ILLUMINANT1_TUNGSTEN, CAM_AWB_A },
213 { ANDROID_SENSOR_REFERENCE_ILLUMINANT1_FINE_WEATHER, CAM_AWB_D50 },
214 { ANDROID_SENSOR_REFERENCE_ILLUMINANT1_CLOUDY_WEATHER, CAM_AWB_D65 },
215 { ANDROID_SENSOR_REFERENCE_ILLUMINANT1_SHADE, CAM_AWB_D75 },
216 { ANDROID_SENSOR_REFERENCE_ILLUMINANT1_DAY_WHITE_FLUORESCENT, CAM_AWB_CUSTOM_DAYLIGHT },
217 { ANDROID_SENSOR_REFERENCE_ILLUMINANT1_WHITE_FLUORESCENT, CAM_AWB_COLD_FLO},
218 };
219
220 camera3_device_ops_t QCamera3HardwareInterface::mCameraOps = {
221 initialize: QCamera3HardwareInterface::initialize,
222 configure_streams: QCamera3HardwareInterface::configure_streams,
223 register_stream_buffers: NULL,
224 construct_default_request_settings: QCamera3HardwareInterface::construct_default_request_settings,
225 process_capture_request: QCamera3HardwareInterface::process_capture_request,
226 get_metadata_vendor_tag_ops: NULL,
227 dump: QCamera3HardwareInterface::dump,
228 flush: QCamera3HardwareInterface::flush,
229 reserved: {0},
230 };
231
232 /*===========================================================================
233 * FUNCTION : QCamera3HardwareInterface
234 *
235 * DESCRIPTION: constructor of QCamera3HardwareInterface
236 *
237 * PARAMETERS :
238 * @cameraId : camera ID
239 *
240 * RETURN : none
241 *==========================================================================*/
QCamera3HardwareInterface(int cameraId,const camera_module_callbacks_t * callbacks)242 QCamera3HardwareInterface::QCamera3HardwareInterface(int cameraId,
243 const camera_module_callbacks_t *callbacks)
244 : mCameraId(cameraId),
245 mCameraHandle(NULL),
246 mCameraOpened(false),
247 mCameraInitialized(false),
248 mCallbackOps(NULL),
249 mMetadataChannel(NULL),
250 mPictureChannel(NULL),
251 mRawChannel(NULL),
252 mSupportChannel(NULL),
253 mRawDumpChannel(NULL),
254 mFirstRequest(false),
255 mFlush(false),
256 mParamHeap(NULL),
257 mParameters(NULL),
258 mPrevParameters(NULL),
259 m_bIsVideo(false),
260 m_bIs4KVideo(false),
261 mEisEnable(0),
262 mLoopBackResult(NULL),
263 mMinProcessedFrameDuration(0),
264 mMinJpegFrameDuration(0),
265 mMinRawFrameDuration(0),
266 m_pPowerModule(NULL),
267 mMetaFrameCount(0),
268 mCallbacks(callbacks),
269 mCaptureIntent(0)
270 {
271 getLogLevel();
272 mCameraDevice.common.tag = HARDWARE_DEVICE_TAG;
273 mCameraDevice.common.version = CAMERA_DEVICE_API_VERSION_3_3;
274 mCameraDevice.common.close = close_camera_device;
275 mCameraDevice.ops = &mCameraOps;
276 mCameraDevice.priv = this;
277 gCamCapability[cameraId]->version = CAM_HAL_V3;
278 // TODO: hardcode for now until mctl add support for min_num_pp_bufs
279 //TBD - To see if this hardcoding is needed. Check by printing if this is filled by mctl to 3
280 gCamCapability[cameraId]->min_num_pp_bufs = 3;
281
282 pthread_cond_init(&mRequestCond, NULL);
283 mPendingRequest = 0;
284 mCurrentRequestId = -1;
285 pthread_mutex_init(&mMutex, NULL);
286
287 for (size_t i = 0; i < CAMERA3_TEMPLATE_COUNT; i++)
288 mDefaultMetadata[i] = NULL;
289
290 #ifdef HAS_MULTIMEDIA_HINTS
291 if (hw_get_module(POWER_HARDWARE_MODULE_ID, (const hw_module_t **)&m_pPowerModule)) {
292 ALOGE("%s: %s module not found", __func__, POWER_HARDWARE_MODULE_ID);
293 }
294 #endif
295
296 char prop[PROPERTY_VALUE_MAX];
297 property_get("persist.camera.raw.dump", prop, "0");
298 mEnableRawDump = atoi(prop);
299 if (mEnableRawDump)
300 CDBG("%s: Raw dump from Camera HAL enabled", __func__);
301
302 mPendingBuffersMap.num_buffers = 0;
303 mPendingBuffersMap.last_frame_number = -1;
304 }
305
306 /*===========================================================================
307 * FUNCTION : ~QCamera3HardwareInterface
308 *
309 * DESCRIPTION: destructor of QCamera3HardwareInterface
310 *
311 * PARAMETERS : none
312 *
313 * RETURN : none
314 *==========================================================================*/
~QCamera3HardwareInterface()315 QCamera3HardwareInterface::~QCamera3HardwareInterface()
316 {
317 CDBG("%s: E", __func__);
318 /* We need to stop all streams before deleting any stream */
319
320 bool hasPendingBuffers = (mPendingBuffersMap.num_buffers > 0);
321
322 if (mRawDumpChannel) {
323 mRawDumpChannel->stop();
324 }
325
326 // NOTE: 'camera3_stream_t *' objects are already freed at
327 // this stage by the framework
328 for (List<stream_info_t *>::iterator it = mStreamInfo.begin();
329 it != mStreamInfo.end(); it++) {
330 QCamera3Channel *channel = (*it)->channel;
331 if (channel) {
332 channel->stop();
333 }
334 }
335 if (mSupportChannel)
336 mSupportChannel->stop();
337
338 for (List<stream_info_t *>::iterator it = mStreamInfo.begin();
339 it != mStreamInfo.end(); it++) {
340 QCamera3Channel *channel = (*it)->channel;
341 if (channel)
342 delete channel;
343 free (*it);
344 }
345 if (mSupportChannel) {
346 delete mSupportChannel;
347 mSupportChannel = NULL;
348 }
349
350 if (mRawDumpChannel) {
351 delete mRawDumpChannel;
352 mRawDumpChannel = NULL;
353 }
354 mPictureChannel = NULL;
355
356 /* Clean up all channels */
357 if (mCameraInitialized) {
358 if (mMetadataChannel) {
359 mMetadataChannel->stop();
360 delete mMetadataChannel;
361 mMetadataChannel = NULL;
362 }
363
364 memset(mParameters, 0, sizeof(parm_buffer_t));
365 // Check if there is still pending buffer not yet returned.
366 if (hasPendingBuffers) {
367 for (auto& pendingBuffer : mPendingBuffersMap.mPendingBufferList) {
368 ALOGE("%s: Buffer not yet returned for stream. Frame number %d, format 0x%x, width %d, height %d",
369 __func__, pendingBuffer.frame_number, pendingBuffer.stream->format, pendingBuffer.stream->width,
370 pendingBuffer.stream->height);
371 }
372 ALOGE("%s: Last requested frame number is %d", __func__, mPendingBuffersMap.last_frame_number);
373
374 uint8_t restart = TRUE;
375 AddSetParmEntryToBatch(mParameters, CAM_INTF_META_DAEMON_RESTART,
376 sizeof(restart), &restart);
377 }
378
379 int rc = mCameraHandle->ops->set_parms(mCameraHandle->camera_handle, mParameters);
380 if (rc < 0) {
381 ALOGE("%s: set_parms failed for unconfigure", __func__);
382 }
383 deinitParameters();
384 }
385
386 if (mCameraOpened)
387 closeCamera();
388
389 mPendingBuffersMap.mPendingBufferList.clear();
390 mPendingRequestsList.clear();
391 mPendingReprocessResultList.clear();
392
393 for (size_t i = 0; i < CAMERA3_TEMPLATE_COUNT; i++)
394 if (mDefaultMetadata[i])
395 free_camera_metadata(mDefaultMetadata[i]);
396
397 pthread_cond_destroy(&mRequestCond);
398
399 pthread_mutex_destroy(&mMutex);
400
401 if (hasPendingBuffers) {
402 ALOGE("%s: Not all buffers were returned. Notified the camera daemon process to restart."
403 " Exiting here...", __func__);
404 exit(EXIT_FAILURE);
405 }
406 CDBG("%s: X", __func__);
407 }
408
409 /*===========================================================================
410 * FUNCTION : camEvtHandle
411 *
412 * DESCRIPTION: Function registered to mm-camera-interface to handle events
413 *
414 * PARAMETERS :
415 * @camera_handle : interface layer camera handle
416 * @evt : ptr to event
417 * @user_data : user data ptr
418 *
419 * RETURN : none
420 *==========================================================================*/
camEvtHandle(uint32_t,mm_camera_event_t * evt,void * user_data)421 void QCamera3HardwareInterface::camEvtHandle(uint32_t /*camera_handle*/,
422 mm_camera_event_t *evt,
423 void *user_data)
424 {
425 QCamera3HardwareInterface *obj = (QCamera3HardwareInterface *)user_data;
426 camera3_notify_msg_t notify_msg;
427 if (obj && evt) {
428 switch(evt->server_event_type) {
429 case CAM_EVENT_TYPE_DAEMON_DIED:
430 ALOGE("%s: Fatal, camera daemon died", __func__);
431
432 //close the camera backend
433 if (obj->mCameraHandle && obj->mCameraHandle->camera_handle
434 && obj->mCameraHandle->ops) {
435 obj->mCameraHandle->ops->error_close_camera(obj->mCameraHandle->camera_handle);
436 } else {
437 ALOGE("%s: Could not close camera on error because the handle or ops is NULL",
438 __func__);
439 }
440 memset(¬ify_msg, 0, sizeof(camera3_notify_msg_t));
441 notify_msg.type = CAMERA3_MSG_ERROR;
442 notify_msg.message.error.error_code = CAMERA3_MSG_ERROR_DEVICE;
443 notify_msg.message.error.error_stream = NULL;
444 notify_msg.message.error.frame_number = 0;
445 obj->mCallbackOps->notify(obj->mCallbackOps, ¬ify_msg);
446 break;
447
448 case CAM_EVENT_TYPE_DAEMON_PULL_REQ:
449 CDBG("%s: HAL got request pull from Daemon", __func__);
450 pthread_mutex_lock(&obj->mMutex);
451 obj->mWokenUpByDaemon = true;
452 obj->unblockRequestIfNecessary();
453 pthread_mutex_unlock(&obj->mMutex);
454 break;
455
456 default:
457 CDBG_HIGH("%s: Warning: Unhandled event %d", __func__,
458 evt->server_event_type);
459 break;
460 }
461 } else {
462 ALOGE("%s: NULL user_data/evt", __func__);
463 }
464 }
465
466 /*===========================================================================
467 * FUNCTION : openCamera
468 *
469 * DESCRIPTION: open camera
470 *
471 * PARAMETERS :
472 * @hw_device : double ptr for camera device struct
473 *
474 * RETURN : int32_t type of status
475 * NO_ERROR -- success
476 * none-zero failure code
477 *==========================================================================*/
openCamera(struct hw_device_t ** hw_device)478 int QCamera3HardwareInterface::openCamera(struct hw_device_t **hw_device)
479 {
480 int rc = 0;
481 if (mCameraOpened) {
482 *hw_device = NULL;
483 return PERMISSION_DENIED;
484 }
485
486 rc = openCamera();
487 if (rc == 0) {
488 *hw_device = &mCameraDevice.common;
489 } else
490 *hw_device = NULL;
491
492 #ifdef HAS_MULTIMEDIA_HINTS
493 if (rc == 0) {
494 if (m_pPowerModule) {
495 if (m_pPowerModule->powerHint) {
496 m_pPowerModule->powerHint(m_pPowerModule, POWER_HINT_VIDEO_ENCODE,
497 (void *)"state=1");
498 }
499 }
500 }
501 #endif
502 return rc;
503 }
504
505 /*===========================================================================
506 * FUNCTION : openCamera
507 *
508 * DESCRIPTION: open camera
509 *
510 * PARAMETERS : none
511 *
512 * RETURN : int32_t type of status
513 * NO_ERROR -- success
514 * none-zero failure code
515 *==========================================================================*/
openCamera()516 int QCamera3HardwareInterface::openCamera()
517 {
518 int rc = 0;
519
520 ATRACE_CALL();
521 if (mCameraHandle) {
522 ALOGE("Failure: Camera already opened");
523 return ALREADY_EXISTS;
524 }
525
526 rc = QCameraFlash::getInstance().reserveFlashForCamera(mCameraId);
527 if (rc < 0) {
528 ALOGE("%s: Failed to reserve flash for camera id: %d",
529 __func__,
530 mCameraId);
531 return UNKNOWN_ERROR;
532 }
533
534 mCameraHandle = camera_open(mCameraId);
535 if (!mCameraHandle) {
536 ALOGE("camera_open failed.");
537 return UNKNOWN_ERROR;
538 }
539
540 mCameraOpened = true;
541
542 rc = mCameraHandle->ops->register_event_notify(mCameraHandle->camera_handle,
543 camEvtHandle, (void *)this);
544
545 if (rc < 0) {
546 ALOGE("%s: Error, failed to register event callback", __func__);
547 /* Not closing camera here since it is already handled in destructor */
548 return FAILED_TRANSACTION;
549 }
550
551 return NO_ERROR;
552 }
553
554 /*===========================================================================
555 * FUNCTION : closeCamera
556 *
557 * DESCRIPTION: close camera
558 *
559 * PARAMETERS : none
560 *
561 * RETURN : int32_t type of status
562 * NO_ERROR -- success
563 * none-zero failure code
564 *==========================================================================*/
closeCamera()565 int QCamera3HardwareInterface::closeCamera()
566 {
567 ATRACE_CALL();
568 int rc = NO_ERROR;
569
570 rc = mCameraHandle->ops->close_camera(mCameraHandle->camera_handle);
571 mCameraHandle = NULL;
572 mCameraOpened = false;
573
574 #ifdef HAS_MULTIMEDIA_HINTS
575 if (rc == NO_ERROR) {
576 if (m_pPowerModule) {
577 if (m_pPowerModule->powerHint) {
578 m_pPowerModule->powerHint(m_pPowerModule, POWER_HINT_VIDEO_ENCODE,
579 (void *)"state=0");
580 }
581 }
582 }
583 #endif
584
585 if (QCameraFlash::getInstance().releaseFlashFromCamera(mCameraId) != 0) {
586 CDBG("%s: Failed to release flash for camera id: %d",
587 __func__,
588 mCameraId);
589 }
590
591 return rc;
592 }
593
594 /*===========================================================================
595 * FUNCTION : initialize
596 *
597 * DESCRIPTION: Initialize frameworks callback functions
598 *
599 * PARAMETERS :
600 * @callback_ops : callback function to frameworks
601 *
602 * RETURN :
603 *
604 *==========================================================================*/
initialize(const struct camera3_callback_ops * callback_ops)605 int QCamera3HardwareInterface::initialize(
606 const struct camera3_callback_ops *callback_ops)
607 {
608 ATRACE_CALL();
609 int rc;
610
611 pthread_mutex_lock(&mMutex);
612
613 rc = initParameters();
614 if (rc < 0) {
615 ALOGE("%s: initParamters failed %d", __func__, rc);
616 goto err1;
617 }
618 mCallbackOps = callback_ops;
619
620 pthread_mutex_unlock(&mMutex);
621 mCameraInitialized = true;
622 return 0;
623
624 err1:
625 pthread_mutex_unlock(&mMutex);
626 return rc;
627 }
628
629 /*===========================================================================
630 * FUNCTION : validateStreamDimensions
631 *
632 * DESCRIPTION: Check if the configuration requested are those advertised
633 *
634 * PARAMETERS :
635 * @stream_list : streams to be configured
636 *
637 * RETURN :
638 *
639 *==========================================================================*/
validateStreamDimensions(camera3_stream_configuration_t * streamList)640 int QCamera3HardwareInterface::validateStreamDimensions(
641 camera3_stream_configuration_t *streamList)
642 {
643 int rc = NO_ERROR;
644 int32_t available_processed_sizes[MAX_SIZES_CNT * 2];
645 int32_t available_jpeg_sizes[MAX_SIZES_CNT * 2];
646 uint8_t jpeg_sizes_cnt = 0;
647
648 camera3_stream_t *inputStream = NULL;
649 /*
650 * Loop through all streams to find input stream if it exists*
651 */
652 for (size_t i = 0; i< streamList->num_streams; i++) {
653 if (streamList->streams[i]->stream_type == CAMERA3_STREAM_INPUT) {
654 if (inputStream != NULL) {
655 ALOGE("%s: Error, Multiple input streams requested", __func__);
656 return -EINVAL;
657 }
658 inputStream = streamList->streams[i];
659 }
660 }
661 /*
662 * Loop through all streams requested in configuration
663 * Check if unsupported sizes have been requested on any of them
664 */
665 for (size_t j = 0; j < streamList->num_streams; j++){
666 bool sizeFound = false;
667 camera3_stream_t *newStream = streamList->streams[j];
668
669 uint32_t rotatedHeight = newStream->height;
670 uint32_t rotatedWidth = newStream->width;
671 if ((newStream->rotation == CAMERA3_STREAM_ROTATION_90) ||
672 (newStream->rotation == CAMERA3_STREAM_ROTATION_270)) {
673 rotatedHeight = newStream->width;
674 rotatedWidth = newStream->height;
675 }
676
677 /*
678 * Sizes are different for each type of stream format check against
679 * appropriate table.
680 */
681 switch (newStream->format) {
682 case ANDROID_SCALER_AVAILABLE_FORMATS_RAW16:
683 case ANDROID_SCALER_AVAILABLE_FORMATS_RAW_OPAQUE:
684 case HAL_PIXEL_FORMAT_RAW10:
685 for (int i = 0;
686 i < gCamCapability[mCameraId]->supported_raw_dim_cnt; i++){
687 if (gCamCapability[mCameraId]->raw_dim[i].width
688 == (int32_t) rotatedWidth
689 && gCamCapability[mCameraId]->raw_dim[i].height
690 == (int32_t) rotatedHeight) {
691 sizeFound = true;
692 break;
693 }
694 }
695 break;
696 case HAL_PIXEL_FORMAT_BLOB:
697 /* Generate JPEG sizes table */
698 makeTable(gCamCapability[mCameraId]->picture_sizes_tbl,
699 gCamCapability[mCameraId]->picture_sizes_tbl_cnt,
700 available_processed_sizes);
701 jpeg_sizes_cnt = filterJpegSizes(
702 available_jpeg_sizes,
703 available_processed_sizes,
704 (gCamCapability[mCameraId]->picture_sizes_tbl_cnt) * 2,
705 MAX_SIZES_CNT * 2,
706 gCamCapability[mCameraId]->active_array_size,
707 gCamCapability[mCameraId]->max_downscale_factor);
708
709 /* Verify set size against generated sizes table */
710 for (int i = 0;i < jpeg_sizes_cnt/2; i++) {
711 if ((int32_t) rotatedWidth == available_jpeg_sizes[i*2] &&
712 (int32_t) rotatedHeight == available_jpeg_sizes[i*2+1]) {
713 sizeFound = true;
714 break;
715 }
716 }
717 break;
718
719
720 case HAL_PIXEL_FORMAT_YCbCr_420_888:
721 case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED:
722 default:
723 /* ZSL stream will be full active array size validate that*/
724 if (newStream->stream_type == CAMERA3_STREAM_BIDIRECTIONAL
725 || newStream->stream_type == CAMERA3_STREAM_INPUT
726 || newStream->usage & GRALLOC_USAGE_HW_CAMERA_ZSL){
727 if ((int32_t) rotatedWidth ==
728 gCamCapability[mCameraId]->active_array_size.width
729 && (int32_t) rotatedHeight ==
730 gCamCapability[mCameraId]->active_array_size.height) {
731 sizeFound = true;
732 }
733 /* We could potentially break here to enforce ZSL stream
734 * set from frameworks always has full active array size
735 * but it is not clear from spec if framework will always
736 * follow that, also we have logic to override to full array
737 * size, so keeping this logic lenient at the moment.
738 */
739 }
740
741 /* Non ZSL stream still need to conform to advertised sizes*/
742 for (int i = 0;
743 i < gCamCapability[mCameraId]->picture_sizes_tbl_cnt;i++){
744 if ((int32_t) rotatedWidth ==
745 gCamCapability[mCameraId]->picture_sizes_tbl[i].width
746 && (int32_t) rotatedHeight ==
747 gCamCapability[mCameraId]->picture_sizes_tbl[i].height){
748 sizeFound = true;
749 break;
750 }
751 }
752 break;
753 } /* End of switch(newStream->format) */
754
755 /* We error out even if a single stream has unsupported size set */
756 if (!sizeFound) {
757 ALOGE("%s: Error: Unsupported size of %d x %d requested for stream"
758 "type:%d", __func__, rotatedWidth, rotatedHeight,
759 newStream->format);
760 ALOGE("%s: Active array size is %d x %d", __func__,
761 gCamCapability[mCameraId]->active_array_size.width,
762 gCamCapability[mCameraId]->active_array_size.height);
763 rc = -EINVAL;
764 break;
765 }
766 } /* End of for each stream */
767 return rc;
768 }
769
770 /*==============================================================================
771 * FUNCTION : isSupportChannelNeeded
772 *
773 * DESCRIPTION: Simple heuristic func to determine if support channels is needed
774 *
775 * PARAMETERS :
776 * @stream_list : streams to be configured
777 *
778 * RETURN : Boolen true/false decision
779 *
780 *==========================================================================*/
isSupportChannelNeeded(camera3_stream_configuration_t * streamList,cam_stream_size_info_t stream_config_info)781 bool QCamera3HardwareInterface::isSupportChannelNeeded(camera3_stream_configuration_t *streamList,
782 cam_stream_size_info_t stream_config_info)
783 {
784 uint32_t i;
785 bool bSuperSetPresent = false;
786 /* Check for conditions where PProc pipeline does not have any streams*/
787 for (i = 0; i < stream_config_info.num_streams; i++) {
788 if (stream_config_info.postprocess_mask[i] == CAM_QCOM_FEATURE_PP_SUPERSET) {
789 bSuperSetPresent = true;
790 break;
791 }
792 }
793
794 if (bSuperSetPresent == false )
795 return true;
796
797 /* Dummy stream needed if only raw or jpeg streams present */
798 for (i = 0;i < streamList->num_streams;i++) {
799 switch(streamList->streams[i]->format) {
800 case HAL_PIXEL_FORMAT_RAW_OPAQUE:
801 case HAL_PIXEL_FORMAT_RAW10:
802 case HAL_PIXEL_FORMAT_RAW16:
803 case HAL_PIXEL_FORMAT_BLOB:
804 break;
805 default:
806 return false;
807 }
808 }
809 return true;
810 }
811
812
813 /*===========================================================================
814 * FUNCTION : configureStreams
815 *
816 * DESCRIPTION: Reset HAL camera device processing pipeline and set up new input
817 * and output streams.
818 *
819 * PARAMETERS :
820 * @stream_list : streams to be configured
821 *
822 * RETURN :
823 *
824 *==========================================================================*/
configureStreams(camera3_stream_configuration_t * streamList)825 int QCamera3HardwareInterface::configureStreams(
826 camera3_stream_configuration_t *streamList)
827 {
828 ATRACE_CALL();
829 int rc = 0;
830
831 // Sanity check stream_list
832 if (streamList == NULL) {
833 ALOGE("%s: NULL stream configuration", __func__);
834 return BAD_VALUE;
835 }
836 if (streamList->streams == NULL) {
837 ALOGE("%s: NULL stream list", __func__);
838 return BAD_VALUE;
839 }
840
841 if (streamList->num_streams < 1) {
842 ALOGE("%s: Bad number of streams requested: %d", __func__,
843 streamList->num_streams);
844 return BAD_VALUE;
845 }
846
847 /* first invalidate all the steams in the mStreamList
848 * if they appear again, they will be validated */
849 for (List<stream_info_t*>::iterator it = mStreamInfo.begin();
850 it != mStreamInfo.end(); it++) {
851 QCamera3Channel *channel = (QCamera3Channel*)(*it)->stream->priv;
852 channel->stop();
853 (*it)->status = INVALID;
854 }
855
856 if (mRawDumpChannel) {
857 mRawDumpChannel->stop();
858 delete mRawDumpChannel;
859 mRawDumpChannel = NULL;
860 }
861
862 if (mSupportChannel)
863 mSupportChannel->stop();
864 if (mMetadataChannel) {
865 /* If content of mStreamInfo is not 0, there is metadata stream */
866 mMetadataChannel->stop();
867 }
868
869 pthread_mutex_lock(&mMutex);
870
871 /* Check whether we have video stream */
872 m_bIs4KVideo = false;
873 m_bIsVideo = false;
874 bool isZsl = false;
875 size_t videoWidth = 0;
876 size_t videoHeight = 0;
877 size_t rawStreamCnt = 0;
878 size_t stallStreamCnt = 0;
879 size_t processedStreamCnt = 0;
880 // Number of streams on ISP encoder path
881 size_t numStreamsOnEncoder = 0;
882 cam_dimension_t maxViewfinderSize;
883 bool bJpegExceeds4K = false;
884 bool bUseCommonFeatureMask = false;
885 uint32_t commonFeatureMask = 0;
886 maxViewfinderSize = gCamCapability[mCameraId]->max_viewfinder_size;
887 camera3_stream_t *inputStream = NULL;
888
889 for (size_t i = 0; i < streamList->num_streams; i++) {
890 camera3_stream_t *newStream = streamList->streams[i];
891 CDBG_HIGH("%s: stream[%d] type = %d, format = %d, width = %d, "
892 "height = %d, rotation = %d",
893 __func__, i, newStream->stream_type, newStream->format,
894 newStream->width, newStream->height, newStream->rotation);
895
896 if (newStream->stream_type == CAMERA3_STREAM_BIDIRECTIONAL ||
897 newStream->stream_type == CAMERA3_STREAM_INPUT){
898 isZsl = true;
899 }
900 if (newStream->stream_type == CAMERA3_STREAM_INPUT){
901 inputStream = newStream;
902 }
903
904 if (newStream->format == HAL_PIXEL_FORMAT_BLOB) {
905 if (newStream->width > VIDEO_4K_WIDTH ||
906 newStream->height > VIDEO_4K_HEIGHT)
907 bJpegExceeds4K = true;
908 }
909
910 if ((HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED == newStream->format) &&
911 (newStream->usage & private_handle_t::PRIV_FLAGS_VIDEO_ENCODER)) {
912 m_bIsVideo = true;
913
914 if ((VIDEO_4K_WIDTH <= newStream->width) &&
915 (VIDEO_4K_HEIGHT <= newStream->height)) {
916 videoWidth = newStream->width;
917 videoHeight = newStream->height;
918 m_bIs4KVideo = true;
919 }
920 }
921 if (newStream->stream_type == CAMERA3_STREAM_BIDIRECTIONAL ||
922 newStream->stream_type == CAMERA3_STREAM_OUTPUT) {
923 switch (newStream->format) {
924 case HAL_PIXEL_FORMAT_BLOB:
925 stallStreamCnt++;
926 if (newStream->width > (uint32_t)maxViewfinderSize.width ||
927 newStream->height > (uint32_t)maxViewfinderSize.height) {
928 commonFeatureMask |= CAM_QCOM_FEATURE_NONE;
929 numStreamsOnEncoder++;
930 }
931 break;
932 case HAL_PIXEL_FORMAT_RAW10:
933 case HAL_PIXEL_FORMAT_RAW_OPAQUE:
934 case HAL_PIXEL_FORMAT_RAW16:
935 rawStreamCnt++;
936 break;
937 case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED:
938 processedStreamCnt++;
939 if (newStream->width > (uint32_t)maxViewfinderSize.width ||
940 newStream->height > (uint32_t)maxViewfinderSize.height) {
941 if (newStream->stream_type == CAMERA3_STREAM_BIDIRECTIONAL ||
942 newStream->usage & GRALLOC_USAGE_HW_CAMERA_ZSL) {
943 commonFeatureMask |= CAM_QCOM_FEATURE_NONE;
944 } else {
945 commonFeatureMask |= CAM_QCOM_FEATURE_PP_SUPERSET;
946 }
947 numStreamsOnEncoder++;
948 }
949 break;
950 case HAL_PIXEL_FORMAT_YCbCr_420_888:
951 default:
952 processedStreamCnt++;
953 if (newStream->width > (uint32_t)maxViewfinderSize.width ||
954 newStream->height > (uint32_t)maxViewfinderSize.height) {
955 commonFeatureMask |= CAM_QCOM_FEATURE_PP_SUPERSET;
956 numStreamsOnEncoder++;
957 }
958 break;
959 }
960
961 }
962 }
963
964 /* Check if num_streams is sane */
965 if (stallStreamCnt > MAX_STALLING_STREAMS ||
966 rawStreamCnt > MAX_RAW_STREAMS ||
967 processedStreamCnt > MAX_PROCESSED_STREAMS) {
968 ALOGE("%s: Invalid stream configu: stall: %d, raw: %d, processed %d",
969 __func__, stallStreamCnt, rawStreamCnt, processedStreamCnt);
970 pthread_mutex_unlock(&mMutex);
971 return -EINVAL;
972 }
973 /* Check whether we have zsl stream or 4k video case */
974 if (isZsl && m_bIsVideo) {
975 ALOGE("%s: Currently invalid configuration ZSL&Video!", __func__);
976 pthread_mutex_unlock(&mMutex);
977 return -EINVAL;
978 }
979 /* Check if stream sizes are sane */
980 if (numStreamsOnEncoder > 2) {
981 ALOGE("%s: Number of streams on ISP encoder path exceeds limits of 2",
982 __func__);
983 pthread_mutex_unlock(&mMutex);
984 return -EINVAL;
985 } else if (1 < numStreamsOnEncoder){
986 bUseCommonFeatureMask = true;
987 CDBG_HIGH("%s: Multiple streams above max viewfinder size, common mask needed",
988 __func__);
989 }
990 /* Check if BLOB size is greater than 4k in 4k recording case */
991 if (m_bIs4KVideo && bJpegExceeds4K) {
992 ALOGE("%s: HAL doesn't support Blob size greater than 4k in 4k recording",
993 __func__);
994 pthread_mutex_unlock(&mMutex);
995 return -EINVAL;
996 }
997
998 rc = validateStreamDimensions(streamList);
999 if (rc == NO_ERROR) {
1000 rc = validateStreamRotations(streamList);
1001 }
1002 if (rc != NO_ERROR) {
1003 ALOGE("%s: Invalid stream configuration requested!", __func__);
1004 pthread_mutex_unlock(&mMutex);
1005 return rc;
1006 }
1007
1008 camera3_stream_t *zslStream = NULL; //Only use this for size and not actual handle!
1009 camera3_stream_t *jpegStream = NULL;
1010 cam_stream_size_info_t stream_config_info;
1011 memset(&stream_config_info, 0, sizeof(cam_stream_size_info_t));
1012 for (size_t i = 0; i < streamList->num_streams; i++) {
1013 camera3_stream_t *newStream = streamList->streams[i];
1014 CDBG_HIGH("%s: newStream type = %d, stream format = %d "
1015 "stream size : %d x %d, stream rotation = %d",
1016 __func__, newStream->stream_type, newStream->format,
1017 newStream->width, newStream->height, newStream->rotation);
1018 //if the stream is in the mStreamList validate it
1019 bool stream_exists = false;
1020 for (List<stream_info_t*>::iterator it=mStreamInfo.begin();
1021 it != mStreamInfo.end(); it++) {
1022 if ((*it)->stream == newStream) {
1023 QCamera3Channel *channel =
1024 (QCamera3Channel*)(*it)->stream->priv;
1025 stream_exists = true;
1026 if (channel)
1027 delete channel;
1028 (*it)->status = VALID;
1029 (*it)->stream->priv = NULL;
1030 (*it)->channel = NULL;
1031 }
1032 }
1033 if (!stream_exists && newStream->stream_type != CAMERA3_STREAM_INPUT) {
1034 //new stream
1035 stream_info_t* stream_info;
1036 stream_info = (stream_info_t* )malloc(sizeof(stream_info_t));
1037 stream_info->stream = newStream;
1038 stream_info->status = VALID;
1039 stream_info->channel = NULL;
1040 mStreamInfo.push_back(stream_info);
1041 }
1042 /* Covers Opaque ZSL and API1 F/W ZSL */
1043 if (newStream->usage & GRALLOC_USAGE_HW_CAMERA_ZSL
1044 || newStream->stream_type == CAMERA3_STREAM_BIDIRECTIONAL ) {
1045 if (zslStream != NULL) {
1046 ALOGE("%s: Multiple input/reprocess streams requested!", __func__);
1047 pthread_mutex_unlock(&mMutex);
1048 return BAD_VALUE;
1049 }
1050 zslStream = newStream;
1051 }
1052 /* Covers YUV reprocess */
1053 if (inputStream != NULL) {
1054 if (newStream->stream_type == CAMERA3_STREAM_OUTPUT
1055 && newStream->format == HAL_PIXEL_FORMAT_YCbCr_420_888
1056 && inputStream->format == HAL_PIXEL_FORMAT_YCbCr_420_888
1057 && inputStream->width == newStream->width
1058 && inputStream->height == newStream->height) {
1059 if (zslStream != NULL) {
1060 /* This scenario indicates multiple YUV streams with same size
1061 * as input stream have been requested, since zsl stream handle
1062 * is solely use for the purpose of overriding the size of streams
1063 * which share h/w streams we will just make a guess here as to
1064 * which of the stream is a ZSL stream, this will be refactored
1065 * once we make generic logic for streams sharing encoder output
1066 */
1067 CDBG_HIGH("%s: Warning, Multiple ip/reprocess streams requested!", __func__);
1068 }
1069 zslStream = newStream;
1070 }
1071 }
1072 if (newStream->format == HAL_PIXEL_FORMAT_BLOB) {
1073 jpegStream = newStream;
1074 }
1075 }
1076
1077 cleanAndSortStreamInfo();
1078 if (mMetadataChannel) {
1079 delete mMetadataChannel;
1080 mMetadataChannel = NULL;
1081 }
1082 if (mSupportChannel) {
1083 delete mSupportChannel;
1084 mSupportChannel = NULL;
1085 }
1086
1087 //Create metadata channel and initialize it
1088 mMetadataChannel = new QCamera3MetadataChannel(mCameraHandle->camera_handle,
1089 mCameraHandle->ops, captureResultCb,
1090 &gCamCapability[mCameraId]->padding_info, CAM_QCOM_FEATURE_NONE, this);
1091 if (mMetadataChannel == NULL) {
1092 ALOGE("%s: failed to allocate metadata channel", __func__);
1093 rc = -ENOMEM;
1094 pthread_mutex_unlock(&mMutex);
1095 return rc;
1096 }
1097 rc = mMetadataChannel->initialize(IS_TYPE_NONE);
1098 if (rc < 0) {
1099 ALOGE("%s: metadata channel initialization failed", __func__);
1100 delete mMetadataChannel;
1101 mMetadataChannel = NULL;
1102 pthread_mutex_unlock(&mMutex);
1103 return rc;
1104 }
1105
1106 bool isRawStreamRequested = false;
1107 /* Allocate channel objects for the requested streams */
1108 for (size_t i = 0; i < streamList->num_streams; i++) {
1109 camera3_stream_t *newStream = streamList->streams[i];
1110 uint32_t stream_usage = newStream->usage;
1111 stream_config_info.stream_sizes[stream_config_info.num_streams].width = newStream->width;
1112 stream_config_info.stream_sizes[stream_config_info.num_streams].height = newStream->height;
1113 if ((newStream->stream_type == CAMERA3_STREAM_BIDIRECTIONAL
1114 || newStream->usage & GRALLOC_USAGE_HW_CAMERA_ZSL)
1115 && newStream->format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED
1116 && jpegStream){
1117 //for zsl stream the size is active array size
1118 // FIXME remove this for api zsl bidirectional is alway active array size
1119 // and for hal 3.3 reprocess, we will *indirectly* control using input size.
1120 // there is a grey area however when the application whimsically decides to create
1121 // a standalone zsl stream whose size < jpeg blob size
1122 /*
1123 stream_config_info.stream_sizes[stream_config_info.num_streams].width =
1124 gCamCapability[mCameraId]->active_array_size.width;
1125 stream_config_info.stream_sizes[stream_config_info.num_streams].height =
1126 gCamCapability[mCameraId]->active_array_size.height;
1127 */
1128 stream_config_info.type[stream_config_info.num_streams] = CAM_STREAM_TYPE_SNAPSHOT;
1129 stream_config_info.postprocess_mask[stream_config_info.num_streams] = CAM_QCOM_FEATURE_NONE;
1130 } else if(newStream->stream_type == CAMERA3_STREAM_INPUT) {
1131 CDBG_HIGH("%s: Input stream configured, reprocess config", __func__);
1132 } else {
1133 //for non zsl streams find out the format
1134 switch (newStream->format) {
1135 case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED :
1136 {
1137 if (stream_usage & private_handle_t::PRIV_FLAGS_VIDEO_ENCODER) {
1138 stream_config_info.type[stream_config_info.num_streams] = CAM_STREAM_TYPE_VIDEO;
1139 } else {
1140 stream_config_info.type[stream_config_info.num_streams] = CAM_STREAM_TYPE_PREVIEW;
1141 }
1142 stream_config_info.postprocess_mask[stream_config_info.num_streams] = CAM_QCOM_FEATURE_PP_SUPERSET;
1143
1144 if ((newStream->rotation == CAMERA3_STREAM_ROTATION_90) ||
1145 (newStream->rotation == CAMERA3_STREAM_ROTATION_270)) {
1146 stream_config_info.stream_sizes[stream_config_info.num_streams].width =
1147 newStream->height;
1148 stream_config_info.stream_sizes[stream_config_info.num_streams].height =
1149 newStream->width;
1150 }
1151 }
1152 break;
1153 case HAL_PIXEL_FORMAT_YCbCr_420_888:
1154 stream_config_info.type[stream_config_info.num_streams] = CAM_STREAM_TYPE_CALLBACK;
1155 stream_config_info.postprocess_mask[stream_config_info.num_streams] = CAM_QCOM_FEATURE_PP_SUPERSET;
1156 break;
1157 case HAL_PIXEL_FORMAT_BLOB:
1158 stream_config_info.type[stream_config_info.num_streams] = CAM_STREAM_TYPE_SNAPSHOT;
1159 if (m_bIs4KVideo && !isZsl) {
1160 stream_config_info.postprocess_mask[stream_config_info.num_streams] = CAM_QCOM_FEATURE_PP_SUPERSET;
1161 } else {
1162 if (bUseCommonFeatureMask &&
1163 (newStream->width > (uint32_t)maxViewfinderSize.width ||
1164 newStream->height > (uint32_t)maxViewfinderSize.height)) {
1165 stream_config_info.postprocess_mask[stream_config_info.num_streams] = commonFeatureMask;
1166 } else {
1167 stream_config_info.postprocess_mask[stream_config_info.num_streams] = CAM_QCOM_FEATURE_NONE;
1168 }
1169 }
1170 if (isZsl) {
1171 if (zslStream) {
1172 stream_config_info.stream_sizes[stream_config_info.num_streams].width =
1173 zslStream->width;
1174 stream_config_info.stream_sizes[stream_config_info.num_streams].height =
1175 zslStream->height;
1176 } else {
1177 ALOGE("%s: Error, No ZSL stream identified",__func__);
1178 pthread_mutex_unlock(&mMutex);
1179 return -EINVAL;
1180 }
1181 } else if (m_bIs4KVideo) {
1182 stream_config_info.stream_sizes[stream_config_info.num_streams].width = videoWidth;
1183 stream_config_info.stream_sizes[stream_config_info.num_streams].height = videoHeight;
1184 }
1185 break;
1186 case HAL_PIXEL_FORMAT_RAW_OPAQUE:
1187 case HAL_PIXEL_FORMAT_RAW16:
1188 case HAL_PIXEL_FORMAT_RAW10:
1189 stream_config_info.type[stream_config_info.num_streams] = CAM_STREAM_TYPE_RAW;
1190 isRawStreamRequested = true;
1191 break;
1192 default:
1193 stream_config_info.type[stream_config_info.num_streams] = CAM_STREAM_TYPE_DEFAULT;
1194 stream_config_info.postprocess_mask[stream_config_info.num_streams] = CAM_QCOM_FEATURE_NONE;
1195 break;
1196 }
1197
1198 }
1199 if (newStream->priv == NULL) {
1200 //New stream, construct channel
1201 switch (newStream->stream_type) {
1202 case CAMERA3_STREAM_INPUT:
1203 newStream->usage = GRALLOC_USAGE_HW_CAMERA_READ;
1204 newStream->usage |= GRALLOC_USAGE_HW_CAMERA_WRITE;//WR for inplace algo's
1205 break;
1206 case CAMERA3_STREAM_BIDIRECTIONAL:
1207 newStream->usage = GRALLOC_USAGE_HW_CAMERA_READ |
1208 GRALLOC_USAGE_HW_CAMERA_WRITE;
1209 break;
1210 case CAMERA3_STREAM_OUTPUT:
1211 /* For video encoding stream, set read/write rarely
1212 * flag so that they may be set to un-cached */
1213 if (newStream->usage & GRALLOC_USAGE_HW_VIDEO_ENCODER)
1214 newStream->usage =
1215 (GRALLOC_USAGE_SW_READ_RARELY |
1216 GRALLOC_USAGE_SW_WRITE_RARELY |
1217 GRALLOC_USAGE_HW_CAMERA_WRITE);
1218 else if (newStream->usage & GRALLOC_USAGE_HW_CAMERA_ZSL)
1219 CDBG("%s: ZSL usage flag skipping", __func__);
1220 else
1221 newStream->usage = GRALLOC_USAGE_HW_CAMERA_WRITE;
1222 break;
1223 default:
1224 ALOGE("%s: Invalid stream_type %d", __func__, newStream->stream_type);
1225 break;
1226 }
1227
1228 if (newStream->stream_type == CAMERA3_STREAM_OUTPUT ||
1229 newStream->stream_type == CAMERA3_STREAM_BIDIRECTIONAL) {
1230 QCamera3Channel *channel = NULL;
1231 switch (newStream->format) {
1232 case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED:
1233 case HAL_PIXEL_FORMAT_YCbCr_420_888:
1234 newStream->max_buffers = QCamera3RegularChannel::kMaxBuffers;
1235 channel = new QCamera3RegularChannel(mCameraHandle->camera_handle,
1236 mCameraHandle->ops, captureResultCb,
1237 &gCamCapability[mCameraId]->padding_info,
1238 this,
1239 newStream,
1240 (cam_stream_type_t) stream_config_info.type[stream_config_info.num_streams],
1241 stream_config_info.postprocess_mask[stream_config_info.num_streams]);
1242 if (channel == NULL) {
1243 ALOGE("%s: allocation of channel failed", __func__);
1244 pthread_mutex_unlock(&mMutex);
1245 return -ENOMEM;
1246 }
1247
1248 newStream->priv = channel;
1249 break;
1250 case HAL_PIXEL_FORMAT_RAW_OPAQUE:
1251 case HAL_PIXEL_FORMAT_RAW16:
1252 case HAL_PIXEL_FORMAT_RAW10:
1253 newStream->max_buffers = QCamera3RawChannel::kMaxBuffers;
1254 mRawChannel = new QCamera3RawChannel(
1255 mCameraHandle->camera_handle,
1256 mCameraHandle->ops, captureResultCb,
1257 &gCamCapability[mCameraId]->padding_info,
1258 this, newStream, CAM_QCOM_FEATURE_NONE,
1259 (newStream->format == HAL_PIXEL_FORMAT_RAW16));
1260 if (mRawChannel == NULL) {
1261 ALOGE("%s: allocation of raw channel failed", __func__);
1262 pthread_mutex_unlock(&mMutex);
1263 return -ENOMEM;
1264 }
1265
1266 newStream->priv = (QCamera3Channel*)mRawChannel;
1267 break;
1268 case HAL_PIXEL_FORMAT_BLOB:
1269 newStream->max_buffers = QCamera3PicChannel::kMaxBuffers;
1270 mPictureChannel = new QCamera3PicChannel(mCameraHandle->camera_handle,
1271 mCameraHandle->ops, captureResultCb,
1272 &gCamCapability[mCameraId]->padding_info, this, newStream,
1273 stream_config_info.postprocess_mask[stream_config_info.num_streams],
1274 m_bIs4KVideo, mMetadataChannel);
1275 if (mPictureChannel == NULL) {
1276 ALOGE("%s: allocation of channel failed", __func__);
1277 pthread_mutex_unlock(&mMutex);
1278 return -ENOMEM;
1279 }
1280 newStream->priv = (QCamera3Channel*)mPictureChannel;
1281 break;
1282
1283 default:
1284 ALOGE("%s: not a supported format 0x%x", __func__, newStream->format);
1285 break;
1286 }
1287 } else if (newStream->stream_type == CAMERA3_STREAM_INPUT) {
1288 newStream->max_buffers = MAX_INFLIGHT_REPROCESS_REQUESTS;
1289 } else {
1290 ALOGE("%s: Error, Unknown stream type", __func__);
1291 return -EINVAL;
1292 }
1293
1294 for (List<stream_info_t*>::iterator it=mStreamInfo.begin();
1295 it != mStreamInfo.end(); it++) {
1296 if ((*it)->stream == newStream) {
1297 (*it)->channel = (QCamera3Channel*) newStream->priv;
1298 break;
1299 }
1300 }
1301 } else {
1302 // Channel already exists for this stream
1303 // Do nothing for now
1304 }
1305
1306 /* Do not add entries for input stream in metastream info
1307 * since there is no real stream associated with it
1308 */
1309 if (newStream->stream_type != CAMERA3_STREAM_INPUT)
1310 stream_config_info.num_streams++;
1311 }
1312
1313 if (isZsl) {
1314 if (zslStream == NULL) {
1315 ALOGE("%s: Error Zsl stream handle missing", __func__);
1316 pthread_mutex_unlock(&mMutex);
1317 return -EINVAL;
1318 }
1319 /* This override is possible since the f/w gaurantees that the ZSL
1320 stream will always be the active array size in case of Bidirectional
1321 or will be limited to the max i/p stream size which we can control to
1322 be equal to be the largest YUV/Opaque stream size
1323 */
1324 if (mPictureChannel) {
1325 mPictureChannel->overrideYuvSize(zslStream->width, zslStream->height);
1326 }
1327 } else if (mPictureChannel && m_bIs4KVideo) {
1328 mPictureChannel->overrideYuvSize(videoWidth, videoHeight);
1329 }
1330
1331 if (isSupportChannelNeeded(streamList, stream_config_info)) {
1332 mSupportChannel = new QCamera3SupportChannel(
1333 mCameraHandle->camera_handle,
1334 mCameraHandle->ops,
1335 &gCamCapability[mCameraId]->padding_info,
1336 CAM_QCOM_FEATURE_NONE,
1337 this);
1338 if (!mSupportChannel) {
1339 ALOGE("%s: dummy channel cannot be created", __func__);
1340 pthread_mutex_unlock(&mMutex);
1341 return -ENOMEM;
1342 }
1343 }
1344
1345 //RAW DUMP channel
1346 if (mEnableRawDump && isRawStreamRequested == false){
1347 cam_dimension_t rawDumpSize;
1348 rawDumpSize = getMaxRawSize(mCameraId);
1349 mRawDumpChannel = new QCamera3RawDumpChannel(mCameraHandle->camera_handle,
1350 mCameraHandle->ops,
1351 rawDumpSize,
1352 &gCamCapability[mCameraId]->padding_info,
1353 this, CAM_QCOM_FEATURE_NONE);
1354 if (!mRawDumpChannel) {
1355 ALOGE("%s: Raw Dump channel cannot be created", __func__);
1356 pthread_mutex_unlock(&mMutex);
1357 return -ENOMEM;
1358 }
1359 }
1360
1361
1362 if (mSupportChannel) {
1363 stream_config_info.stream_sizes[stream_config_info.num_streams] =
1364 QCamera3SupportChannel::kDim;
1365 stream_config_info.type[stream_config_info.num_streams] =
1366 CAM_STREAM_TYPE_CALLBACK;
1367 stream_config_info.postprocess_mask[stream_config_info.num_streams] =
1368 CAM_QCOM_FEATURE_PP_SUPERSET;
1369 stream_config_info.num_streams++;
1370 }
1371
1372 if (mRawDumpChannel) {
1373 cam_dimension_t rawSize;
1374 rawSize = getMaxRawSize(mCameraId);
1375 stream_config_info.stream_sizes[stream_config_info.num_streams] =
1376 rawSize;
1377 stream_config_info.type[stream_config_info.num_streams] =
1378 CAM_STREAM_TYPE_RAW;
1379 stream_config_info.num_streams++;
1380 }
1381
1382 mStreamConfigInfo = stream_config_info;
1383
1384 /* Initialize mPendingRequestInfo and mPendnigBuffersMap */
1385 mPendingRequestsList.clear();
1386 mPendingFrameDropList.clear();
1387 // Initialize/Reset the pending buffers list
1388 mPendingBuffersMap.num_buffers = 0;
1389 mPendingBuffersMap.mPendingBufferList.clear();
1390 mPendingReprocessResultList.clear();
1391
1392 mFirstRequest = true;
1393
1394 //Get min frame duration for this streams configuration
1395 deriveMinFrameDuration();
1396
1397 pthread_mutex_unlock(&mMutex);
1398 return rc;
1399 }
1400
1401 /*===========================================================================
1402 * FUNCTION : validateCaptureRequest
1403 *
1404 * DESCRIPTION: validate a capture request from camera service
1405 *
1406 * PARAMETERS :
1407 * @request : request from framework to process
1408 *
1409 * RETURN :
1410 *
1411 *==========================================================================*/
validateCaptureRequest(camera3_capture_request_t * request)1412 int QCamera3HardwareInterface::validateCaptureRequest(
1413 camera3_capture_request_t *request)
1414 {
1415 ssize_t idx = 0;
1416 const camera3_stream_buffer_t *b;
1417 CameraMetadata meta;
1418
1419 /* Sanity check the request */
1420 if (request == NULL) {
1421 ALOGE("%s: NULL capture request", __func__);
1422 return BAD_VALUE;
1423 }
1424
1425 if (request->settings == NULL && mFirstRequest) {
1426 /*settings cannot be null for the first request*/
1427 return BAD_VALUE;
1428 }
1429
1430 uint32_t frameNumber = request->frame_number;
1431 if (request->num_output_buffers < 1 || request->output_buffers == NULL) {
1432 ALOGE("%s: Request %d: No output buffers provided!",
1433 __FUNCTION__, frameNumber);
1434 return BAD_VALUE;
1435 }
1436 if (request->input_buffer != NULL) {
1437 b = request->input_buffer;
1438 if (b->status != CAMERA3_BUFFER_STATUS_OK) {
1439 ALOGE("%s: Request %d: Buffer %ld: Status not OK!",
1440 __func__, frameNumber, (long)idx);
1441 return BAD_VALUE;
1442 }
1443 if (b->release_fence != -1) {
1444 ALOGE("%s: Request %d: Buffer %ld: Has a release fence!",
1445 __func__, frameNumber, (long)idx);
1446 return BAD_VALUE;
1447 }
1448 if (b->buffer == NULL) {
1449 ALOGE("%s: Request %d: Buffer %ld: NULL buffer handle!",
1450 __func__, frameNumber, (long)idx);
1451 return BAD_VALUE;
1452 }
1453 }
1454
1455 // Validate all buffers
1456 b = request->output_buffers;
1457 do {
1458 QCamera3Channel *channel =
1459 static_cast<QCamera3Channel*>(b->stream->priv);
1460 if (channel == NULL) {
1461 ALOGE("%s: Request %d: Buffer %ld: Unconfigured stream!",
1462 __func__, frameNumber, (long)idx);
1463 return BAD_VALUE;
1464 }
1465 if (b->status != CAMERA3_BUFFER_STATUS_OK) {
1466 ALOGE("%s: Request %d: Buffer %ld: Status not OK!",
1467 __func__, frameNumber, (long)idx);
1468 return BAD_VALUE;
1469 }
1470 if (b->release_fence != -1) {
1471 ALOGE("%s: Request %d: Buffer %ld: Has a release fence!",
1472 __func__, frameNumber, (long)idx);
1473 return BAD_VALUE;
1474 }
1475 if (b->buffer == NULL) {
1476 ALOGE("%s: Request %d: Buffer %ld: NULL buffer handle!",
1477 __func__, frameNumber, (long)idx);
1478 return BAD_VALUE;
1479 }
1480 if (*(b->buffer) == NULL) {
1481 ALOGE("%s: Request %d: Buffer %ld: NULL private handle!",
1482 __func__, frameNumber, (long)idx);
1483 return BAD_VALUE;
1484 }
1485 idx++;
1486 b = request->output_buffers + idx;
1487 } while (idx < (ssize_t)request->num_output_buffers);
1488
1489 return NO_ERROR;
1490 }
1491
1492 /*===========================================================================
1493 * FUNCTION : deriveMinFrameDuration
1494 *
1495 * DESCRIPTION: derive mininum processed, jpeg, and raw frame durations based
1496 * on currently configured streams.
1497 *
1498 * PARAMETERS : NONE
1499 *
1500 * RETURN : NONE
1501 *
1502 *==========================================================================*/
deriveMinFrameDuration()1503 void QCamera3HardwareInterface::deriveMinFrameDuration()
1504 {
1505 int32_t maxJpegDim, maxProcessedDim, maxRawDim;
1506
1507 maxJpegDim = 0;
1508 maxProcessedDim = 0;
1509 maxRawDim = 0;
1510
1511 // Figure out maximum jpeg, processed, and raw dimensions
1512 for (List<stream_info_t*>::iterator it = mStreamInfo.begin();
1513 it != mStreamInfo.end(); it++) {
1514
1515 // Input stream doesn't have valid stream_type
1516 if ((*it)->stream->stream_type == CAMERA3_STREAM_INPUT)
1517 continue;
1518
1519 int32_t dimension = (*it)->stream->width * (*it)->stream->height;
1520 if ((*it)->stream->format == HAL_PIXEL_FORMAT_BLOB) {
1521 if (dimension > maxJpegDim)
1522 maxJpegDim = dimension;
1523 } else if ((*it)->stream->format == HAL_PIXEL_FORMAT_RAW_OPAQUE ||
1524 (*it)->stream->format == HAL_PIXEL_FORMAT_RAW10 ||
1525 (*it)->stream->format == HAL_PIXEL_FORMAT_RAW16) {
1526 if (dimension > maxRawDim)
1527 maxRawDim = dimension;
1528 } else {
1529 if (dimension > maxProcessedDim)
1530 maxProcessedDim = dimension;
1531 }
1532 }
1533
1534 //Assume all jpeg dimensions are in processed dimensions.
1535 if (maxJpegDim > maxProcessedDim)
1536 maxProcessedDim = maxJpegDim;
1537 //Find the smallest raw dimension that is greater or equal to jpeg dimension
1538 if (maxProcessedDim > maxRawDim) {
1539 maxRawDim = INT32_MAX;
1540 for (int i = 0; i < gCamCapability[mCameraId]->supported_raw_dim_cnt;
1541 i++) {
1542
1543 int32_t dimension =
1544 gCamCapability[mCameraId]->raw_dim[i].width *
1545 gCamCapability[mCameraId]->raw_dim[i].height;
1546
1547 if (dimension >= maxProcessedDim && dimension < maxRawDim)
1548 maxRawDim = dimension;
1549 }
1550 }
1551
1552 //Find minimum durations for processed, jpeg, and raw
1553 for (int i = 0; i < gCamCapability[mCameraId]->supported_raw_dim_cnt;
1554 i++) {
1555 if (maxRawDim == gCamCapability[mCameraId]->raw_dim[i].width *
1556 gCamCapability[mCameraId]->raw_dim[i].height) {
1557 mMinRawFrameDuration = gCamCapability[mCameraId]->raw_min_duration[i];
1558 break;
1559 }
1560 }
1561 for (int i = 0; i < gCamCapability[mCameraId]->picture_sizes_tbl_cnt; i++) {
1562 if (maxProcessedDim ==
1563 gCamCapability[mCameraId]->picture_sizes_tbl[i].width *
1564 gCamCapability[mCameraId]->picture_sizes_tbl[i].height) {
1565 mMinProcessedFrameDuration = gCamCapability[mCameraId]->picture_min_duration[i];
1566 mMinJpegFrameDuration = gCamCapability[mCameraId]->picture_min_duration[i];
1567 break;
1568 }
1569 }
1570 }
1571
1572 /*===========================================================================
1573 * FUNCTION : getMinFrameDuration
1574 *
1575 * DESCRIPTION: get minimum frame draution based on the current maximum frame durations
1576 * and current request configuration.
1577 *
1578 * PARAMETERS : @request: requset sent by the frameworks
1579 *
1580 * RETURN : min farme duration for a particular request
1581 *
1582 *==========================================================================*/
getMinFrameDuration(const camera3_capture_request_t * request)1583 int64_t QCamera3HardwareInterface::getMinFrameDuration(const camera3_capture_request_t *request)
1584 {
1585 bool hasJpegStream = false;
1586 for (uint32_t i = 0; i < request->num_output_buffers; i ++) {
1587 const camera3_stream_t *stream = request->output_buffers[i].stream;
1588 if (stream->format == HAL_PIXEL_FORMAT_BLOB)
1589 hasJpegStream = true;
1590 }
1591
1592 if (!hasJpegStream)
1593 return MAX(mMinRawFrameDuration, mMinProcessedFrameDuration);
1594 else
1595 return MAX(MAX(mMinRawFrameDuration, mMinProcessedFrameDuration), mMinJpegFrameDuration);
1596 }
1597
1598 /*===========================================================================
1599 * FUNCTION : handlePendingReprocResults
1600 *
1601 * DESCRIPTION: check and notify on any pending reprocess results
1602 *
1603 * PARAMETERS :
1604 * @frame_number : Pending request frame number
1605 *
1606 * RETURN : int32_t type of status
1607 * NO_ERROR -- success
1608 * none-zero failure code
1609 *==========================================================================*/
handlePendingReprocResults(uint32_t frame_number)1610 int32_t QCamera3HardwareInterface::handlePendingReprocResults(uint32_t frame_number)
1611 {
1612 for (List<PendingReprocessResult>::iterator j = mPendingReprocessResultList.begin();
1613 j != mPendingReprocessResultList.end(); j++) {
1614 if (j->frame_number == frame_number) {
1615 mCallbackOps->notify(mCallbackOps, &j->notify_msg);
1616
1617 CDBG("%s: Delayed reprocess notify %d", __func__,
1618 frame_number);
1619
1620 for (List<PendingRequestInfo>::iterator k = mPendingRequestsList.begin();
1621 k != mPendingRequestsList.end(); k++) {
1622
1623 if (k->frame_number == j->frame_number) {
1624 CDBG("%s: Found reprocess frame number %d in pending reprocess List "
1625 "Take it out!!", __func__,
1626 k->frame_number);
1627
1628 camera3_capture_result result;
1629 memset(&result, 0, sizeof(camera3_capture_result));
1630 result.frame_number = frame_number;
1631 result.num_output_buffers = 1;
1632 result.output_buffers = &j->buffer;
1633 result.input_buffer = k->input_buffer;
1634 result.result = k->settings;
1635 result.partial_result = PARTIAL_RESULT_COUNT;
1636 mCallbackOps->process_capture_result(mCallbackOps, &result);
1637
1638 mPendingRequestsList.erase(k);
1639 mPendingRequest--;
1640 break;
1641 }
1642 }
1643 mPendingReprocessResultList.erase(j);
1644 break;
1645 }
1646 }
1647 return NO_ERROR;
1648 }
1649
1650 /*===========================================================================
1651 * FUNCTION : handleMetadataWithLock
1652 *
1653 * DESCRIPTION: Handles metadata buffer callback with mMutex lock held.
1654 *
1655 * PARAMETERS : @metadata_buf: metadata buffer
1656 *
1657 * RETURN :
1658 *
1659 *==========================================================================*/
handleMetadataWithLock(mm_camera_super_buf_t * metadata_buf)1660 void QCamera3HardwareInterface::handleMetadataWithLock(
1661 mm_camera_super_buf_t *metadata_buf)
1662 {
1663 ATRACE_CALL();
1664
1665 int32_t frame_number_valid = 0;
1666 uint32_t frame_number = 0;
1667 int64_t capture_time = 0;
1668 int32_t urgent_frame_number_valid = 0;
1669 uint32_t urgent_frame_number = 0;
1670
1671 metadata_buffer_t *metadata = (metadata_buffer_t *)metadata_buf->bufs[0]->buffer;
1672 cam_frame_dropped_t cam_frame_drop =
1673 *(cam_frame_dropped_t *) POINTER_OF_META(CAM_INTF_META_FRAME_DROPPED, metadata);
1674
1675 int32_t *p_frame_number_valid =
1676 (int32_t *) POINTER_OF_META(CAM_INTF_META_FRAME_NUMBER_VALID, metadata);
1677 uint32_t *p_frame_number =
1678 (uint32_t *) POINTER_OF_META(CAM_INTF_META_FRAME_NUMBER, metadata);
1679 int64_t *p_capture_time =
1680 (int64_t *) POINTER_OF_META(CAM_INTF_META_SENSOR_TIMESTAMP, metadata);
1681 int32_t *p_urgent_frame_number_valid =
1682 (int32_t *) POINTER_OF_META(CAM_INTF_META_URGENT_FRAME_NUMBER_VALID, metadata);
1683 uint32_t *p_urgent_frame_number =
1684 (uint32_t *) POINTER_OF_META(CAM_INTF_META_URGENT_FRAME_NUMBER, metadata);
1685
1686 if ((NULL == p_frame_number_valid) ||
1687 (NULL == p_frame_number) ||
1688 (NULL == p_capture_time) ||
1689 (NULL == p_urgent_frame_number_valid) ||
1690 (NULL == p_urgent_frame_number))
1691 {
1692 mMetadataChannel->bufDone(metadata_buf);
1693 free(metadata_buf);
1694 goto done_metadata;
1695 }
1696 else
1697 {
1698 frame_number_valid = *p_frame_number_valid;
1699 frame_number = *p_frame_number;
1700 capture_time = *p_capture_time;
1701 urgent_frame_number_valid = *p_urgent_frame_number_valid;
1702 urgent_frame_number = *p_urgent_frame_number;
1703 }
1704
1705 if (urgent_frame_number_valid) {
1706 CDBG("%s: valid urgent frame_number = %d, capture_time = %lld",
1707 __func__, urgent_frame_number, capture_time);
1708
1709 //Recieved an urgent Frame Number, handle it
1710 //using partial results
1711 for (List<PendingRequestInfo>::iterator i =
1712 mPendingRequestsList.begin(); i != mPendingRequestsList.end(); i++) {
1713 CDBG("%s: Iterator Frame = %d urgent frame = %d",
1714 __func__, i->frame_number, urgent_frame_number);
1715
1716 if (i->frame_number < urgent_frame_number &&
1717 i->partial_result_cnt == 0) {
1718 ALOGE("%s: Error: HAL missed urgent metadata for frame number %d",
1719 __func__, i->frame_number);
1720 }
1721
1722 if (i->frame_number == urgent_frame_number &&
1723 i->bUrgentReceived == 0) {
1724
1725 camera3_capture_result_t result;
1726 memset(&result, 0, sizeof(camera3_capture_result_t));
1727
1728 i->partial_result_cnt++;
1729 i->bUrgentReceived = 1;
1730 // Extract 3A metadata
1731 result.result =
1732 translateCbUrgentMetadataToResultMetadata(metadata);
1733
1734 if (result.result == NULL)
1735 {
1736 CameraMetadata dummyMetadata;
1737 dummyMetadata.update(ANDROID_SENSOR_TIMESTAMP,
1738 &i->timestamp, 1);
1739 dummyMetadata.update(ANDROID_REQUEST_ID,
1740 &(i->request_id), 1);
1741 result.result = dummyMetadata.release();
1742 }
1743
1744 // Populate metadata result
1745 result.frame_number = urgent_frame_number;
1746 result.num_output_buffers = 0;
1747 result.output_buffers = NULL;
1748 result.partial_result = i->partial_result_cnt;
1749
1750 mCallbackOps->process_capture_result(mCallbackOps, &result);
1751 CDBG("%s: urgent frame_number = %d, capture_time = %lld",
1752 __func__, result.frame_number, capture_time);
1753 free_camera_metadata((camera_metadata_t *)result.result);
1754 break;
1755 }
1756 }
1757 }
1758
1759 if (!frame_number_valid) {
1760 CDBG("%s: Not a valid normal frame number, used as SOF only", __func__);
1761 mMetadataChannel->bufDone(metadata_buf);
1762 free(metadata_buf);
1763 goto done_metadata;
1764 }
1765 CDBG("%s: valid frame_number = %d, capture_time = %lld", __func__,
1766 frame_number, capture_time);
1767
1768 // Go through the pending requests info and send shutter/results to frameworks
1769 for (List<PendingRequestInfo>::iterator i = mPendingRequestsList.begin();
1770 i != mPendingRequestsList.end() && i->frame_number <= frame_number;) {
1771 camera3_capture_result_t result;
1772 memset(&result, 0, sizeof(camera3_capture_result_t));
1773
1774 CDBG("%s: frame_number in the list is %d", __func__, i->frame_number);
1775 i->partial_result_cnt++;
1776 result.partial_result = i->partial_result_cnt;
1777
1778 // Flush out all entries with less or equal frame numbers.
1779 mPendingRequest--;
1780
1781 // Check whether any stream buffer corresponding to this is dropped or not
1782 // If dropped, then send the ERROR_BUFFER for the corresponding stream
1783 if (cam_frame_drop.frame_dropped) {
1784 camera3_notify_msg_t notify_msg;
1785 for (List<RequestedBufferInfo>::iterator j = i->buffers.begin();
1786 j != i->buffers.end(); j++) {
1787 QCamera3Channel *channel = (QCamera3Channel *)j->stream->priv;
1788 uint32_t streamID = channel->getStreamID(channel->getStreamTypeMask());
1789 for (uint32_t k = 0; k < cam_frame_drop.cam_stream_ID.num_streams; k++) {
1790 if (streamID == cam_frame_drop.cam_stream_ID.streamID[k]) {
1791 // Send Error notify to frameworks with CAMERA3_MSG_ERROR_BUFFER
1792 ALOGW("%s: Start of reporting error frame#=%d, streamID=%d",
1793 __func__, i->frame_number, streamID);
1794 notify_msg.type = CAMERA3_MSG_ERROR;
1795 notify_msg.message.error.frame_number = i->frame_number;
1796 notify_msg.message.error.error_code = CAMERA3_MSG_ERROR_BUFFER ;
1797 notify_msg.message.error.error_stream = j->stream;
1798 mCallbackOps->notify(mCallbackOps, ¬ify_msg);
1799 ALOGW("%s: End of reporting error frame#=%d, streamID=%d",
1800 __func__, i->frame_number, streamID);
1801 PendingFrameDropInfo PendingFrameDrop;
1802 PendingFrameDrop.frame_number=i->frame_number;
1803 PendingFrameDrop.stream_ID = streamID;
1804 // Add the Frame drop info to mPendingFrameDropList
1805 mPendingFrameDropList.push_back(PendingFrameDrop);
1806 }
1807 }
1808 }
1809 }
1810
1811 // Send empty metadata with already filled buffers for dropped metadata
1812 // and send valid metadata with already filled buffers for current metadata
1813 if (i->frame_number < frame_number) {
1814 camera3_notify_msg_t notify_msg;
1815 notify_msg.type = CAMERA3_MSG_SHUTTER;
1816 notify_msg.message.shutter.frame_number = i->frame_number;
1817 notify_msg.message.shutter.timestamp = capture_time -
1818 (urgent_frame_number - i->frame_number) * NSEC_PER_33MSEC;
1819 mCallbackOps->notify(mCallbackOps, ¬ify_msg);
1820 i->timestamp = notify_msg.message.shutter.timestamp;
1821 CDBG("%s: Support notification !!!! notify frame_number = %d, capture_time = %lld",
1822 __func__, i->frame_number, notify_msg.message.shutter.timestamp);
1823
1824 CameraMetadata dummyMetadata;
1825 dummyMetadata.update(ANDROID_SENSOR_TIMESTAMP,
1826 &i->timestamp, 1);
1827 dummyMetadata.update(ANDROID_REQUEST_ID,
1828 &(i->request_id), 1);
1829 result.result = dummyMetadata.release();
1830 } else {
1831 // Send shutter notify to frameworks
1832 camera3_notify_msg_t notify_msg;
1833 notify_msg.type = CAMERA3_MSG_SHUTTER;
1834 notify_msg.message.shutter.frame_number = i->frame_number;
1835 notify_msg.message.shutter.timestamp = capture_time;
1836 mCallbackOps->notify(mCallbackOps, ¬ify_msg);
1837
1838 i->timestamp = capture_time;
1839
1840 result.result = translateFromHalMetadata(metadata,
1841 i->timestamp, i->request_id, i->jpegMetadata, i->pipeline_depth,
1842 i->capture_intent);
1843
1844 if (i->blob_request) {
1845 {
1846 //Dump tuning metadata if enabled and available
1847 char prop[PROPERTY_VALUE_MAX];
1848 memset(prop, 0, sizeof(prop));
1849 property_get("persist.camera.dumpmetadata", prop, "0");
1850 int32_t enabled = atoi(prop);
1851 if (enabled && metadata->is_tuning_params_valid) {
1852 dumpMetadataToFile(metadata->tuning_params,
1853 mMetaFrameCount,
1854 enabled,
1855 "Snapshot",
1856 frame_number);
1857 }
1858 }
1859
1860
1861 mPictureChannel->queueReprocMetadata(metadata_buf);
1862 } else {
1863 // Return metadata buffer
1864 mMetadataChannel->bufDone(metadata_buf);
1865 free(metadata_buf);
1866 }
1867 }
1868 if (!result.result) {
1869 ALOGE("%s: metadata is NULL", __func__);
1870 }
1871 result.frame_number = i->frame_number;
1872 result.num_output_buffers = 0;
1873 result.output_buffers = NULL;
1874 for (List<RequestedBufferInfo>::iterator j = i->buffers.begin();
1875 j != i->buffers.end(); j++) {
1876 if (j->buffer) {
1877 result.num_output_buffers++;
1878 }
1879 }
1880
1881 if (result.num_output_buffers > 0) {
1882 camera3_stream_buffer_t *result_buffers =
1883 new camera3_stream_buffer_t[result.num_output_buffers];
1884 if (!result_buffers) {
1885 ALOGE("%s: Fatal error: out of memory", __func__);
1886 }
1887 size_t result_buffers_idx = 0;
1888 for (List<RequestedBufferInfo>::iterator j = i->buffers.begin();
1889 j != i->buffers.end(); j++) {
1890 if (j->buffer) {
1891 for (List<PendingFrameDropInfo>::iterator m = mPendingFrameDropList.begin();
1892 m != mPendingFrameDropList.end(); m++) {
1893 QCamera3Channel *channel = (QCamera3Channel *)j->buffer->stream->priv;
1894 uint32_t streamID = channel->getStreamID(channel->getStreamTypeMask());
1895 if((m->stream_ID == streamID) && (m->frame_number==frame_number)) {
1896 j->buffer->status=CAMERA3_BUFFER_STATUS_ERROR;
1897 CDBG("%s: Stream STATUS_ERROR frame_number=%d, streamID=%d",
1898 __func__, frame_number, streamID);
1899 m = mPendingFrameDropList.erase(m);
1900 break;
1901 }
1902 }
1903
1904 for (List<PendingBufferInfo>::iterator k =
1905 mPendingBuffersMap.mPendingBufferList.begin();
1906 k != mPendingBuffersMap.mPendingBufferList.end(); k++) {
1907 if (k->buffer == j->buffer->buffer) {
1908 CDBG("%s: Found buffer %p in pending buffer List "
1909 "for frame %d, Take it out!!", __func__,
1910 k->buffer, k->frame_number);
1911 mPendingBuffersMap.num_buffers--;
1912 k = mPendingBuffersMap.mPendingBufferList.erase(k);
1913 break;
1914 }
1915 }
1916
1917 result_buffers[result_buffers_idx++] = *(j->buffer);
1918 free(j->buffer);
1919 j->buffer = NULL;
1920 }
1921 }
1922 result.output_buffers = result_buffers;
1923 mCallbackOps->process_capture_result(mCallbackOps, &result);
1924 CDBG("%s: meta frame_number = %d, capture_time = %lld",
1925 __func__, result.frame_number, i->timestamp);
1926 free_camera_metadata((camera_metadata_t *)result.result);
1927 delete[] result_buffers;
1928 } else {
1929 mCallbackOps->process_capture_result(mCallbackOps, &result);
1930 CDBG("%s: meta frame_number = %d, capture_time = %lld",
1931 __func__, result.frame_number, i->timestamp);
1932 free_camera_metadata((camera_metadata_t *)result.result);
1933 }
1934 // erase the element from the list
1935 i = mPendingRequestsList.erase(i);
1936
1937 if (!mPendingReprocessResultList.empty()) {
1938 handlePendingReprocResults(frame_number + 1);
1939 }
1940 }
1941
1942 done_metadata:
1943 for (List<PendingRequestInfo>::iterator i = mPendingRequestsList.begin();
1944 i != mPendingRequestsList.end() ;i++) {
1945 i->pipeline_depth++;
1946 }
1947 unblockRequestIfNecessary();
1948
1949 }
1950
1951 /*===========================================================================
1952 * FUNCTION : handleBufferWithLock
1953 *
1954 * DESCRIPTION: Handles image buffer callback with mMutex lock held.
1955 *
1956 * PARAMETERS : @buffer: image buffer for the callback
1957 * @frame_number: frame number of the image buffer
1958 *
1959 * RETURN :
1960 *
1961 *==========================================================================*/
handleBufferWithLock(camera3_stream_buffer_t * buffer,uint32_t frame_number)1962 void QCamera3HardwareInterface::handleBufferWithLock(
1963 camera3_stream_buffer_t *buffer, uint32_t frame_number)
1964 {
1965 ATRACE_CALL();
1966 // If the frame number doesn't exist in the pending request list,
1967 // directly send the buffer to the frameworks, and update pending buffers map
1968 // Otherwise, book-keep the buffer.
1969 List<PendingRequestInfo>::iterator i = mPendingRequestsList.begin();
1970 while (i != mPendingRequestsList.end() && i->frame_number != frame_number){
1971 i++;
1972 }
1973 if (i == mPendingRequestsList.end()) {
1974 // Verify all pending requests frame_numbers are greater
1975 for (List<PendingRequestInfo>::iterator j = mPendingRequestsList.begin();
1976 j != mPendingRequestsList.end(); j++) {
1977 if (j->frame_number < frame_number) {
1978 ALOGE("%s: Error: pending frame number %d is smaller than %d",
1979 __func__, j->frame_number, frame_number);
1980 }
1981 }
1982 camera3_capture_result_t result;
1983 memset(&result, 0, sizeof(camera3_capture_result_t));
1984 result.result = NULL;
1985 result.frame_number = frame_number;
1986 result.num_output_buffers = 1;
1987 result.partial_result = 0;
1988 for (List<PendingFrameDropInfo>::iterator m = mPendingFrameDropList.begin();
1989 m != mPendingFrameDropList.end(); m++) {
1990 QCamera3Channel *channel = (QCamera3Channel *)buffer->stream->priv;
1991 uint32_t streamID = channel->getStreamID(channel->getStreamTypeMask());
1992 if((m->stream_ID == streamID) && (m->frame_number==frame_number) ) {
1993 buffer->status=CAMERA3_BUFFER_STATUS_ERROR;
1994 CDBG("%s: Stream STATUS_ERROR frame_number=%d, streamID=%d",
1995 __func__, frame_number, streamID);
1996 m = mPendingFrameDropList.erase(m);
1997 break;
1998 }
1999 }
2000 result.output_buffers = buffer;
2001 CDBG("%s: result frame_number = %d, buffer = %p",
2002 __func__, frame_number, buffer->buffer);
2003
2004 for (List<PendingBufferInfo>::iterator k =
2005 mPendingBuffersMap.mPendingBufferList.begin();
2006 k != mPendingBuffersMap.mPendingBufferList.end(); k++ ) {
2007 if (k->buffer == buffer->buffer) {
2008 CDBG("%s: Found Frame buffer, take it out from list",
2009 __func__);
2010
2011 mPendingBuffersMap.num_buffers--;
2012 k = mPendingBuffersMap.mPendingBufferList.erase(k);
2013 break;
2014 }
2015 }
2016 CDBG("%s: mPendingBuffersMap.num_buffers = %d",
2017 __func__, mPendingBuffersMap.num_buffers);
2018
2019 mCallbackOps->process_capture_result(mCallbackOps, &result);
2020 } else {
2021 if (i->input_buffer) {
2022 CameraMetadata settings;
2023 camera3_notify_msg_t notify_msg;
2024 memset(¬ify_msg, 0, sizeof(camera3_notify_msg_t));
2025 nsecs_t capture_time = systemTime(CLOCK_MONOTONIC);
2026 if(i->settings) {
2027 settings = i->settings;
2028 if (settings.exists(ANDROID_SENSOR_TIMESTAMP)) {
2029 capture_time = settings.find(ANDROID_SENSOR_TIMESTAMP).data.i64[0];
2030 } else {
2031 ALOGE("%s: No timestamp in input settings! Using current one.",
2032 __func__);
2033 }
2034 } else {
2035 ALOGE("%s: Input settings missing!", __func__);
2036 }
2037
2038 notify_msg.type = CAMERA3_MSG_SHUTTER;
2039 notify_msg.message.shutter.frame_number = frame_number;
2040 notify_msg.message.shutter.timestamp = capture_time;
2041
2042 if (i->input_buffer->release_fence != -1) {
2043 int32_t rc = sync_wait(i->input_buffer->release_fence, TIMEOUT_NEVER);
2044 close(i->input_buffer->release_fence);
2045 if (rc != OK) {
2046 ALOGE("%s: input buffer sync wait failed %d", __func__, rc);
2047 }
2048 }
2049
2050 for (List<PendingBufferInfo>::iterator k =
2051 mPendingBuffersMap.mPendingBufferList.begin();
2052 k != mPendingBuffersMap.mPendingBufferList.end(); k++ ) {
2053 if (k->buffer == buffer->buffer) {
2054 CDBG("%s: Found Frame buffer, take it out from list",
2055 __func__);
2056
2057 mPendingBuffersMap.num_buffers--;
2058 k = mPendingBuffersMap.mPendingBufferList.erase(k);
2059 break;
2060 }
2061 }
2062 CDBG("%s: mPendingBuffersMap.num_buffers = %d",
2063 __func__, mPendingBuffersMap.num_buffers);
2064
2065 bool notifyNow = true;
2066 for (List<PendingRequestInfo>::iterator j = mPendingRequestsList.begin();
2067 j != mPendingRequestsList.end(); j++) {
2068 if (j->frame_number < frame_number) {
2069 notifyNow = false;
2070 break;
2071 }
2072 }
2073
2074 if (notifyNow) {
2075 camera3_capture_result result;
2076 memset(&result, 0, sizeof(camera3_capture_result));
2077 result.frame_number = frame_number;
2078 result.result = i->settings;
2079 result.input_buffer = i->input_buffer;
2080 result.num_output_buffers = 1;
2081 result.output_buffers = buffer;
2082 result.partial_result = PARTIAL_RESULT_COUNT;
2083
2084 mCallbackOps->notify(mCallbackOps, ¬ify_msg);
2085 mCallbackOps->process_capture_result(mCallbackOps, &result);
2086 CDBG("%s: Notify reprocess now %d!", __func__, frame_number);
2087 i = mPendingRequestsList.erase(i);
2088 mPendingRequest--;
2089 } else {
2090 // Cache reprocess result for later
2091 PendingReprocessResult pendingResult;
2092 memset(&pendingResult, 0, sizeof(PendingReprocessResult));
2093 pendingResult.notify_msg = notify_msg;
2094 pendingResult.buffer = *buffer;
2095 pendingResult.frame_number = frame_number;
2096 mPendingReprocessResultList.push_back(pendingResult);
2097 CDBG("%s: Cache reprocess result %d!", __func__, frame_number);
2098 }
2099 } else {
2100 for (List<RequestedBufferInfo>::iterator j = i->buffers.begin();
2101 j != i->buffers.end(); j++) {
2102 if (j->stream == buffer->stream) {
2103 if (j->buffer != NULL) {
2104 ALOGE("%s: Error: buffer is already set", __func__);
2105 } else {
2106 j->buffer = (camera3_stream_buffer_t *)malloc(
2107 sizeof(camera3_stream_buffer_t));
2108 *(j->buffer) = *buffer;
2109 CDBG("%s: cache buffer %p at result frame_number %d",
2110 __func__, buffer, frame_number);
2111 }
2112 }
2113 }
2114 }
2115 }
2116 }
2117
2118 /*===========================================================================
2119 * FUNCTION : unblockRequestIfNecessary
2120 *
2121 * DESCRIPTION: Unblock capture_request if max_buffer hasn't been reached. Note
2122 * that mMutex is held when this function is called.
2123 *
2124 * PARAMETERS :
2125 *
2126 * RETURN :
2127 *
2128 *==========================================================================*/
unblockRequestIfNecessary()2129 void QCamera3HardwareInterface::unblockRequestIfNecessary()
2130 {
2131 // Unblock process_capture_request
2132 pthread_cond_signal(&mRequestCond);
2133 }
2134
2135 /*===========================================================================
2136 * FUNCTION : processCaptureRequest
2137 *
2138 * DESCRIPTION: process a capture request from camera service
2139 *
2140 * PARAMETERS :
2141 * @request : request from framework to process
2142 *
2143 * RETURN :
2144 *
2145 *==========================================================================*/
processCaptureRequest(camera3_capture_request_t * request)2146 int QCamera3HardwareInterface::processCaptureRequest(
2147 camera3_capture_request_t *request)
2148 {
2149 ATRACE_CALL();
2150 int rc = NO_ERROR;
2151 int32_t request_id;
2152 CameraMetadata meta;
2153
2154 pthread_mutex_lock(&mMutex);
2155
2156 rc = validateCaptureRequest(request);
2157 if (rc != NO_ERROR) {
2158 ALOGE("%s: incoming request is not valid", __func__);
2159 pthread_mutex_unlock(&mMutex);
2160 return rc;
2161 }
2162
2163 meta = request->settings;
2164
2165 // For first capture request, send capture intent, and
2166 // stream on all streams
2167 if (mFirstRequest) {
2168
2169 // settings/parameters don't carry over for new configureStreams
2170 int32_t hal_version = CAM_HAL_V3;
2171 memset(mParameters, 0, sizeof(metadata_buffer_t));
2172
2173 AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_HAL_VERSION,
2174 sizeof(hal_version), &hal_version);
2175
2176 AddSetParmEntryToBatch(mParameters, CAM_INTF_META_STREAM_INFO,
2177 sizeof(cam_stream_size_info_t), &mStreamConfigInfo);
2178
2179 for (uint32_t i = 0; i < mStreamConfigInfo.num_streams; i++) {
2180 CDBG_HIGH("%s STREAM INFO : type %d, wxh: %d x %d, pp_mask: 0x%x",
2181 __func__, mStreamConfigInfo.type[i],
2182 mStreamConfigInfo.stream_sizes[i].width,
2183 mStreamConfigInfo.stream_sizes[i].height,
2184 mStreamConfigInfo.postprocess_mask[i]);
2185 }
2186
2187 int32_t tintless_value = 1;
2188 AddSetParmEntryToBatch(mParameters,CAM_INTF_PARM_TINTLESS,
2189 sizeof(tintless_value), &tintless_value);
2190
2191 mCameraHandle->ops->set_parms(mCameraHandle->camera_handle, mParameters);
2192 /* get eis information for stream configuration */
2193 cam_is_type_t is_type;
2194 char is_type_value[PROPERTY_VALUE_MAX];
2195 property_get("camera.is_type", is_type_value, "0");
2196 is_type = static_cast<cam_is_type_t>(atoi(is_type_value));
2197
2198 if (meta.exists(ANDROID_CONTROL_CAPTURE_INTENT)) {
2199 int32_t hal_version = CAM_HAL_V3;
2200 uint8_t captureIntent =
2201 meta.find(ANDROID_CONTROL_CAPTURE_INTENT).data.u8[0];
2202 mCaptureIntent = captureIntent;
2203 memset(mParameters, 0, sizeof(parm_buffer_t));
2204 AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_HAL_VERSION,
2205 sizeof(hal_version), &hal_version);
2206 AddSetParmEntryToBatch(mParameters, CAM_INTF_META_CAPTURE_INTENT,
2207 sizeof(captureIntent), &captureIntent);
2208 }
2209
2210 //If EIS is enabled, turn it on for video
2211 //for camera use case, front camcorder and 4k video, no eis
2212 bool setEis = mEisEnable && (gCamCapability[mCameraId]->position == CAM_POSITION_BACK &&
2213 (mCaptureIntent == CAMERA3_TEMPLATE_VIDEO_RECORD ||
2214 mCaptureIntent == CAMERA3_TEMPLATE_VIDEO_SNAPSHOT));
2215 int32_t vsMode;
2216 vsMode = (setEis)? DIS_ENABLE: DIS_DISABLE;
2217 rc = AddSetParmEntryToBatch(mParameters,
2218 CAM_INTF_PARM_DIS_ENABLE,
2219 sizeof(vsMode), &vsMode);
2220
2221 //IS type will be 0 unless EIS is supported. If EIS is supported
2222 //it could either be 1 or 4 depending on the stream and video size
2223 if (setEis){
2224 if (m_bIs4KVideo) {
2225 is_type = IS_TYPE_DIS;
2226 } else {
2227 is_type = IS_TYPE_EIS_2_0;
2228 }
2229 }
2230
2231 for (size_t i = 0; i < request->num_output_buffers; i++) {
2232 const camera3_stream_buffer_t& output = request->output_buffers[i];
2233 QCamera3Channel *channel = (QCamera3Channel *)output.stream->priv;
2234 /*for livesnapshot stream is_type will be DIS*/
2235 if (setEis && output.stream->format == HAL_PIXEL_FORMAT_BLOB) {
2236 rc = channel->registerBuffer(output.buffer, IS_TYPE_DIS);
2237 } else {
2238 rc = channel->registerBuffer(output.buffer, is_type);
2239 }
2240 if (rc < 0) {
2241 ALOGE("%s: registerBuffer failed",
2242 __func__);
2243 pthread_mutex_unlock(&mMutex);
2244 return -ENODEV;
2245 }
2246 }
2247
2248 /*set the capture intent, hal version and dis enable parameters to the backend*/
2249 mCameraHandle->ops->set_parms(mCameraHandle->camera_handle,
2250 mParameters);
2251
2252
2253 //First initialize all streams
2254 for (List<stream_info_t *>::iterator it = mStreamInfo.begin();
2255 it != mStreamInfo.end(); it++) {
2256 QCamera3Channel *channel = (QCamera3Channel *)(*it)->stream->priv;
2257 if (setEis && (*it)->stream->format == HAL_PIXEL_FORMAT_BLOB) {
2258 rc = channel->initialize(IS_TYPE_DIS);
2259 } else {
2260 rc = channel->initialize(is_type);
2261 }
2262 if (NO_ERROR != rc) {
2263 ALOGE("%s : Channel initialization failed %d", __func__, rc);
2264 pthread_mutex_unlock(&mMutex);
2265 return rc;
2266 }
2267 }
2268
2269 if (mRawDumpChannel) {
2270 rc = mRawDumpChannel->initialize(is_type);
2271 if (rc != NO_ERROR) {
2272 ALOGE("%s: Error: Raw Dump Channel init failed", __func__);
2273 pthread_mutex_unlock(&mMutex);
2274 return rc;
2275 }
2276 }
2277 if (mSupportChannel) {
2278 rc = mSupportChannel->initialize(is_type);
2279 if (rc < 0) {
2280 ALOGE("%s: Support channel initialization failed", __func__);
2281 pthread_mutex_unlock(&mMutex);
2282 return rc;
2283 }
2284 }
2285
2286 //Then start them.
2287 CDBG_HIGH("%s: Start META Channel", __func__);
2288 rc = mMetadataChannel->start();
2289 if (rc < 0) {
2290 ALOGE("%s: META channel start failed", __func__);
2291 pthread_mutex_unlock(&mMutex);
2292 return rc;
2293 }
2294
2295 if (mSupportChannel) {
2296 rc = mSupportChannel->start();
2297 if (rc < 0) {
2298 ALOGE("%s: Support channel start failed", __func__);
2299 mMetadataChannel->stop();
2300 pthread_mutex_unlock(&mMutex);
2301 return rc;
2302 }
2303 }
2304 for (List<stream_info_t *>::iterator it = mStreamInfo.begin();
2305 it != mStreamInfo.end(); it++) {
2306 QCamera3Channel *channel = (QCamera3Channel *)(*it)->stream->priv;
2307 CDBG_HIGH("%s: Start Regular Channel mask=%d", __func__, channel->getStreamTypeMask());
2308 rc = channel->start();
2309 if (rc < 0) {
2310 ALOGE("%s: channel start failed", __func__);
2311 pthread_mutex_unlock(&mMutex);
2312 return rc;
2313 }
2314 }
2315
2316 if (mRawDumpChannel) {
2317 CDBG("%s: Starting raw dump stream",__func__);
2318 rc = mRawDumpChannel->start();
2319 if (rc != NO_ERROR) {
2320 ALOGE("%s: Error Starting Raw Dump Channel", __func__);
2321 for (List<stream_info_t *>::iterator it = mStreamInfo.begin();
2322 it != mStreamInfo.end(); it++) {
2323 QCamera3Channel *channel =
2324 (QCamera3Channel *)(*it)->stream->priv;
2325 ALOGE("%s: Stopping Regular Channel mask=%d", __func__,
2326 channel->getStreamTypeMask());
2327 channel->stop();
2328 }
2329 if (mSupportChannel)
2330 mSupportChannel->stop();
2331 mMetadataChannel->stop();
2332 pthread_mutex_unlock(&mMutex);
2333 return rc;
2334 }
2335 }
2336 mWokenUpByDaemon = false;
2337 mPendingRequest = 0;
2338 }
2339
2340 uint32_t frameNumber = request->frame_number;
2341 cam_stream_ID_t streamID;
2342
2343 if (meta.exists(ANDROID_REQUEST_ID)) {
2344 request_id = meta.find(ANDROID_REQUEST_ID).data.i32[0];
2345 mCurrentRequestId = request_id;
2346 CDBG("%s: Received request with id: %d",__func__, request_id);
2347 } else if (mFirstRequest || mCurrentRequestId == -1){
2348 ALOGE("%s: Unable to find request id field, \
2349 & no previous id available", __func__);
2350 return NAME_NOT_FOUND;
2351 } else {
2352 CDBG("%s: Re-using old request id", __func__);
2353 request_id = mCurrentRequestId;
2354 }
2355
2356 CDBG("%s: %d, num_output_buffers = %d input_buffer = %p frame_number = %d",
2357 __func__, __LINE__,
2358 request->num_output_buffers,
2359 request->input_buffer,
2360 frameNumber);
2361 // Acquire all request buffers first
2362 streamID.num_streams = 0;
2363 int blob_request = 0;
2364 uint32_t snapshotStreamId = 0;
2365 for (size_t i = 0; i < request->num_output_buffers; i++) {
2366 const camera3_stream_buffer_t& output = request->output_buffers[i];
2367 QCamera3Channel *channel = (QCamera3Channel *)output.stream->priv;
2368
2369 if (output.stream->format == HAL_PIXEL_FORMAT_BLOB) {
2370 //Call function to store local copy of jpeg data for encode params.
2371 blob_request = 1;
2372 snapshotStreamId = channel->getStreamID(channel->getStreamTypeMask());
2373 }
2374
2375 if (output.acquire_fence != -1) {
2376 rc = sync_wait(output.acquire_fence, TIMEOUT_NEVER);
2377 close(output.acquire_fence);
2378 if (rc != OK) {
2379 ALOGE("%s: sync wait failed %d", __func__, rc);
2380 pthread_mutex_unlock(&mMutex);
2381 return rc;
2382 }
2383 }
2384
2385 streamID.streamID[streamID.num_streams] =
2386 channel->getStreamID(channel->getStreamTypeMask());
2387 streamID.num_streams++;
2388
2389
2390 }
2391
2392 if (blob_request && mRawDumpChannel) {
2393 CDBG("%s: Trigger Raw based on blob request if Raw dump is enabled", __func__);
2394 streamID.streamID[streamID.num_streams] =
2395 mRawDumpChannel->getStreamID(mRawDumpChannel->getStreamTypeMask());
2396 streamID.num_streams++;
2397 }
2398
2399 if(request->input_buffer == NULL) {
2400 rc = setFrameParameters(request, streamID, blob_request, snapshotStreamId);
2401 if (rc < 0) {
2402 ALOGE("%s: fail to set frame parameters", __func__);
2403 pthread_mutex_unlock(&mMutex);
2404 return rc;
2405 }
2406 } else {
2407
2408 if (request->input_buffer->acquire_fence != -1) {
2409 rc = sync_wait(request->input_buffer->acquire_fence, TIMEOUT_NEVER);
2410 close(request->input_buffer->acquire_fence);
2411 if (rc != OK) {
2412 ALOGE("%s: input buffer sync wait failed %d", __func__, rc);
2413 pthread_mutex_unlock(&mMutex);
2414 return rc;
2415 }
2416 }
2417 }
2418
2419 /* Update pending request list and pending buffers map */
2420 PendingRequestInfo pendingRequest;
2421 pendingRequest.frame_number = frameNumber;
2422 pendingRequest.num_buffers = request->num_output_buffers;
2423 pendingRequest.request_id = request_id;
2424 pendingRequest.blob_request = blob_request;
2425 pendingRequest.bUrgentReceived = 0;
2426
2427 pendingRequest.input_buffer = request->input_buffer;
2428 pendingRequest.settings = request->settings;
2429 pendingRequest.pipeline_depth = 0;
2430 pendingRequest.partial_result_cnt = 0;
2431 extractJpegMetadata(pendingRequest.jpegMetadata, request);
2432
2433 //extract capture intent
2434 if (meta.exists(ANDROID_CONTROL_CAPTURE_INTENT)) {
2435 mCaptureIntent =
2436 meta.find(ANDROID_CONTROL_CAPTURE_INTENT).data.u8[0];
2437 }
2438 pendingRequest.capture_intent = mCaptureIntent;
2439
2440 for (size_t i = 0; i < request->num_output_buffers; i++) {
2441 RequestedBufferInfo requestedBuf;
2442 requestedBuf.stream = request->output_buffers[i].stream;
2443 requestedBuf.buffer = NULL;
2444 pendingRequest.buffers.push_back(requestedBuf);
2445
2446 // Add to buffer handle the pending buffers list
2447 PendingBufferInfo bufferInfo;
2448 bufferInfo.frame_number = frameNumber;
2449 bufferInfo.buffer = request->output_buffers[i].buffer;
2450 bufferInfo.stream = request->output_buffers[i].stream;
2451 mPendingBuffersMap.mPendingBufferList.push_back(bufferInfo);
2452 mPendingBuffersMap.num_buffers++;
2453 CDBG("%s: frame = %d, buffer = %p, stream = %p, stream format = %d",
2454 __func__, frameNumber, bufferInfo.buffer, bufferInfo.stream,
2455 bufferInfo.stream->format);
2456 }
2457 CDBG("%s: mPendingBuffersMap.num_buffers = %d",
2458 __func__, mPendingBuffersMap.num_buffers);
2459
2460 mPendingBuffersMap.last_frame_number = frameNumber;
2461 mPendingRequestsList.push_back(pendingRequest);
2462
2463 if(mFlush) {
2464 pthread_mutex_unlock(&mMutex);
2465 return NO_ERROR;
2466 }
2467
2468 // Notify metadata channel we receive a request
2469 mMetadataChannel->request(NULL, frameNumber);
2470
2471 metadata_buffer_t reproc_meta;
2472 memset(&reproc_meta, 0, sizeof(metadata_buffer_t));
2473
2474 if(request->input_buffer != NULL){
2475 rc = setReprocParameters(request, &reproc_meta, snapshotStreamId);
2476 if (NO_ERROR != rc) {
2477 ALOGE("%s: fail to set reproc parameters", __func__);
2478 pthread_mutex_unlock(&mMutex);
2479 return rc;
2480 }
2481 }
2482
2483 // Call request on other streams
2484 for (size_t i = 0; i < request->num_output_buffers; i++) {
2485 const camera3_stream_buffer_t& output = request->output_buffers[i];
2486 QCamera3Channel *channel = (QCamera3Channel *)output.stream->priv;
2487
2488 if (channel == NULL) {
2489 ALOGE("%s: invalid channel pointer for stream", __func__);
2490 continue;
2491 }
2492
2493 if (output.stream->format == HAL_PIXEL_FORMAT_BLOB) {
2494 if (request->input_buffer) {
2495 rc = channel->request(output.buffer, frameNumber,
2496 request->input_buffer, &reproc_meta);
2497 } else if (!request->settings) {
2498 rc = channel->request(output.buffer, frameNumber,
2499 NULL, mPrevParameters);
2500 } else {
2501 rc = channel->request(output.buffer, frameNumber,
2502 NULL, mParameters);
2503 }
2504 if (rc < 0) {
2505 ALOGE("%s: Fail to request on picture channel", __func__);
2506 pthread_mutex_unlock(&mMutex);
2507 return rc;
2508 }
2509 } else {
2510 CDBG("%s: %d, request with buffer %p, frame_number %d", __func__,
2511 __LINE__, output.buffer, frameNumber);
2512 rc = channel->request(output.buffer, frameNumber);
2513 }
2514 if (rc < 0)
2515 ALOGE("%s: request failed", __func__);
2516 }
2517
2518 if(request->input_buffer == NULL) {
2519 /*set the parameters to backend*/
2520 mCameraHandle->ops->set_parms(mCameraHandle->camera_handle, mParameters);
2521 }
2522
2523 mFirstRequest = false;
2524 // Added a timed condition wait
2525 struct timespec ts;
2526 uint8_t isValidTimeout = 1;
2527 rc = clock_gettime(CLOCK_REALTIME, &ts);
2528 if (rc < 0) {
2529 isValidTimeout = 0;
2530 ALOGE("%s: Error reading the real time clock!!", __func__);
2531 }
2532 else {
2533 // Make timeout as 5 sec for request to be honored
2534 ts.tv_sec += 5;
2535 }
2536 //Block on conditional variable
2537
2538 mPendingRequest++;
2539 while (mPendingRequest >= MIN_INFLIGHT_REQUESTS) {
2540 if (!isValidTimeout) {
2541 CDBG("%s: Blocking on conditional wait", __func__);
2542 pthread_cond_wait(&mRequestCond, &mMutex);
2543 }
2544 else {
2545 CDBG("%s: Blocking on timed conditional wait", __func__);
2546 rc = pthread_cond_timedwait(&mRequestCond, &mMutex, &ts);
2547 if (rc == ETIMEDOUT) {
2548 rc = -ENODEV;
2549 ALOGE("%s: Unblocked on timeout!!!!", __func__);
2550 break;
2551 }
2552 }
2553 CDBG("%s: Unblocked", __func__);
2554 if (mWokenUpByDaemon) {
2555 mWokenUpByDaemon = false;
2556 if (mPendingRequest < MAX_INFLIGHT_REQUESTS)
2557 break;
2558 }
2559 }
2560 pthread_mutex_unlock(&mMutex);
2561
2562 return rc;
2563 }
2564
2565 /*===========================================================================
2566 * FUNCTION : dump
2567 *
2568 * DESCRIPTION:
2569 *
2570 * PARAMETERS :
2571 *
2572 *
2573 * RETURN :
2574 *==========================================================================*/
dump(int fd)2575 void QCamera3HardwareInterface::dump(int fd)
2576 {
2577 pthread_mutex_lock(&mMutex);
2578 dprintf(fd, "\n Camera HAL3 information Begin \n");
2579
2580 dprintf(fd, "\nNumber of pending requests: %d \n",
2581 mPendingRequestsList.size());
2582 dprintf(fd, "-------+-------------------+-------------+----------+---------------------\n");
2583 dprintf(fd, " Frame | Number of Buffers | Req Id: | Blob Req | Input buffer present\n");
2584 dprintf(fd, "-------+-------------------+-------------+----------+---------------------\n");
2585 for(List<PendingRequestInfo>::iterator i = mPendingRequestsList.begin();
2586 i != mPendingRequestsList.end(); i++) {
2587 dprintf(fd, " %5d | %17d | %11d | %8d | %p \n",
2588 i->frame_number, i->num_buffers, i->request_id, i->blob_request,
2589 i->input_buffer);
2590 }
2591 dprintf(fd, "\nPending buffer map: Number of buffers: %d\n",
2592 mPendingBuffersMap.num_buffers);
2593 dprintf(fd, "-------+-------------\n");
2594 dprintf(fd, " Frame | Stream type \n");
2595 dprintf(fd, "-------+-------------\n");
2596 for(List<PendingBufferInfo>::iterator i =
2597 mPendingBuffersMap.mPendingBufferList.begin();
2598 i != mPendingBuffersMap.mPendingBufferList.end(); i++) {
2599 dprintf(fd, " %5d | %11d \n",
2600 i->frame_number, i->stream->stream_type);
2601 }
2602 dprintf(fd, "-------+-------------\n");
2603
2604 dprintf(fd, "\nPending frame drop list: %d\n",
2605 mPendingFrameDropList.size());
2606 dprintf(fd, "-------+-----------\n");
2607 dprintf(fd, " Frame | Stream ID \n");
2608 dprintf(fd, "-------+-----------\n");
2609 for(List<PendingFrameDropInfo>::iterator i = mPendingFrameDropList.begin();
2610 i != mPendingFrameDropList.end(); i++) {
2611 dprintf(fd, " %5d | %9d \n",
2612 i->frame_number, i->stream_ID);
2613 }
2614 dprintf(fd, "-------+-----------\n");
2615
2616 dprintf(fd, "\n Camera HAL3 information End \n");
2617 pthread_mutex_unlock(&mMutex);
2618 return;
2619 }
2620
2621 /*===========================================================================
2622 * FUNCTION : flush
2623 *
2624 * DESCRIPTION:
2625 *
2626 * PARAMETERS :
2627 *
2628 *
2629 * RETURN :
2630 *==========================================================================*/
flush()2631 int QCamera3HardwareInterface::flush()
2632 {
2633 ATRACE_CALL();
2634 unsigned int frameNum = 0;
2635 camera3_notify_msg_t notify_msg;
2636 camera3_capture_result_t result;
2637 camera3_stream_buffer_t *pStream_Buf = NULL;
2638 FlushMap flushMap;
2639
2640 CDBG("%s: Unblocking Process Capture Request", __func__);
2641 pthread_mutex_lock(&mMutex);
2642 mFlush = true;
2643 pthread_mutex_unlock(&mMutex);
2644
2645 memset(&result, 0, sizeof(camera3_capture_result_t));
2646
2647 // Stop the Streams/Channels
2648 for (List<stream_info_t *>::iterator it = mStreamInfo.begin();
2649 it != mStreamInfo.end(); it++) {
2650 QCamera3Channel *channel = (QCamera3Channel *)(*it)->stream->priv;
2651 channel->stop();
2652 (*it)->status = INVALID;
2653 }
2654
2655 if (mSupportChannel) {
2656 mSupportChannel->stop();
2657 }
2658 if (mRawDumpChannel) {
2659 mRawDumpChannel->stop();
2660 }
2661 if (mMetadataChannel) {
2662 /* If content of mStreamInfo is not 0, there is metadata stream */
2663 mMetadataChannel->stop();
2664 }
2665
2666 // Mutex Lock
2667 pthread_mutex_lock(&mMutex);
2668
2669 // Unblock process_capture_request
2670 mPendingRequest = 0;
2671 pthread_cond_signal(&mRequestCond);
2672
2673 List<PendingRequestInfo>::iterator i = mPendingRequestsList.begin();
2674 frameNum = i->frame_number;
2675 CDBG("%s: Oldest frame num on mPendingRequestsList = %d",
2676 __func__, frameNum);
2677
2678 // Go through the pending buffers and group them depending
2679 // on frame number
2680 for (List<PendingBufferInfo>::iterator k =
2681 mPendingBuffersMap.mPendingBufferList.begin();
2682 k != mPendingBuffersMap.mPendingBufferList.end();) {
2683
2684 if (k->frame_number < frameNum) {
2685 ssize_t idx = flushMap.indexOfKey(k->frame_number);
2686 if (idx == NAME_NOT_FOUND) {
2687 Vector<PendingBufferInfo> pending;
2688 pending.add(*k);
2689 flushMap.add(k->frame_number, pending);
2690 } else {
2691 Vector<PendingBufferInfo> &pending =
2692 flushMap.editValueFor(k->frame_number);
2693 pending.add(*k);
2694 }
2695
2696 mPendingBuffersMap.num_buffers--;
2697 k = mPendingBuffersMap.mPendingBufferList.erase(k);
2698 } else {
2699 k++;
2700 }
2701 }
2702
2703 for (size_t i = 0; i < flushMap.size(); i++) {
2704 uint32_t frame_number = flushMap.keyAt(i);
2705 const Vector<PendingBufferInfo> &pending = flushMap.valueAt(i);
2706
2707 // Send Error notify to frameworks for each buffer for which
2708 // metadata buffer is already sent
2709 CDBG("%s: Sending ERROR BUFFER for frame %d number of buffer %d",
2710 __func__, frame_number, pending.size());
2711
2712 pStream_Buf = new camera3_stream_buffer_t[pending.size()];
2713 if (NULL == pStream_Buf) {
2714 ALOGE("%s: No memory for pending buffers array", __func__);
2715 pthread_mutex_unlock(&mMutex);
2716 return NO_MEMORY;
2717 }
2718
2719 for (size_t j = 0; j < pending.size(); j++) {
2720 const PendingBufferInfo &info = pending.itemAt(j);
2721 notify_msg.type = CAMERA3_MSG_ERROR;
2722 notify_msg.message.error.error_code = CAMERA3_MSG_ERROR_BUFFER;
2723 notify_msg.message.error.error_stream = info.stream;
2724 notify_msg.message.error.frame_number = frame_number;
2725 pStream_Buf[j].acquire_fence = -1;
2726 pStream_Buf[j].release_fence = -1;
2727 pStream_Buf[j].buffer = info.buffer;
2728 pStream_Buf[j].status = CAMERA3_BUFFER_STATUS_ERROR;
2729 pStream_Buf[j].stream = info.stream;
2730 mCallbackOps->notify(mCallbackOps, ¬ify_msg);
2731 CDBG("%s: notify frame_number = %d stream %p", __func__,
2732 frame_number, info.stream);
2733 }
2734
2735 result.result = NULL;
2736 result.frame_number = frame_number;
2737 result.num_output_buffers = pending.size();
2738 result.output_buffers = pStream_Buf;
2739 mCallbackOps->process_capture_result(mCallbackOps, &result);
2740
2741 delete [] pStream_Buf;
2742 }
2743
2744 CDBG("%s:Sending ERROR REQUEST for all pending requests", __func__);
2745
2746 flushMap.clear();
2747 for (List<PendingBufferInfo>::iterator k =
2748 mPendingBuffersMap.mPendingBufferList.begin();
2749 k != mPendingBuffersMap.mPendingBufferList.end();) {
2750 ssize_t idx = flushMap.indexOfKey(k->frame_number);
2751 if (idx == NAME_NOT_FOUND) {
2752 Vector<PendingBufferInfo> pending;
2753 pending.add(*k);
2754 flushMap.add(k->frame_number, pending);
2755 } else {
2756 Vector<PendingBufferInfo> &pending =
2757 flushMap.editValueFor(k->frame_number);
2758 pending.add(*k);
2759 }
2760
2761 mPendingBuffersMap.num_buffers--;
2762 k = mPendingBuffersMap.mPendingBufferList.erase(k);
2763 }
2764
2765 // Go through the pending requests info and send error request to framework
2766 for (size_t i = 0; i < flushMap.size(); i++) {
2767 uint32_t frame_number = flushMap.keyAt(i);
2768 const Vector<PendingBufferInfo> &pending = flushMap.valueAt(i);
2769 CDBG("%s:Sending ERROR REQUEST for frame %d",
2770 __func__, frame_number);
2771
2772 // Send shutter notify to frameworks
2773 notify_msg.type = CAMERA3_MSG_ERROR;
2774 notify_msg.message.error.error_code = CAMERA3_MSG_ERROR_REQUEST;
2775 notify_msg.message.error.error_stream = NULL;
2776 notify_msg.message.error.frame_number = frame_number;
2777 mCallbackOps->notify(mCallbackOps, ¬ify_msg);
2778
2779 pStream_Buf = new camera3_stream_buffer_t[pending.size()];
2780 if (NULL == pStream_Buf) {
2781 ALOGE("%s: No memory for pending buffers array", __func__);
2782 pthread_mutex_unlock(&mMutex);
2783 return NO_MEMORY;
2784 }
2785
2786 for (size_t j = 0; j < pending.size(); j++) {
2787 const PendingBufferInfo &info = pending.itemAt(j);
2788 pStream_Buf[j].acquire_fence = -1;
2789 pStream_Buf[j].release_fence = -1;
2790 pStream_Buf[j].buffer = info.buffer;
2791 pStream_Buf[j].status = CAMERA3_BUFFER_STATUS_ERROR;
2792 pStream_Buf[j].stream = info.stream;
2793 }
2794
2795 result.num_output_buffers = pending.size();
2796 result.output_buffers = pStream_Buf;
2797 result.result = NULL;
2798 result.frame_number = frame_number;
2799 mCallbackOps->process_capture_result(mCallbackOps, &result);
2800 delete [] pStream_Buf;
2801 }
2802
2803 /* Reset pending buffer list and requests list */
2804 mPendingRequestsList.clear();
2805 /* Reset pending frame Drop list and requests list */
2806 mPendingFrameDropList.clear();
2807
2808 flushMap.clear();
2809 mPendingBuffersMap.num_buffers = 0;
2810 mPendingBuffersMap.mPendingBufferList.clear();
2811 mPendingReprocessResultList.clear();
2812 CDBG("%s: Cleared all the pending buffers ", __func__);
2813
2814 mFlush = false;
2815
2816 // Start the Streams/Channels
2817 int rc = NO_ERROR;
2818 if (mMetadataChannel) {
2819 /* If content of mStreamInfo is not 0, there is metadata stream */
2820 rc = mMetadataChannel->start();
2821 if (rc < 0) {
2822 ALOGE("%s: META channel start failed", __func__);
2823 pthread_mutex_unlock(&mMutex);
2824 return rc;
2825 }
2826 }
2827 for (List<stream_info_t *>::iterator it = mStreamInfo.begin();
2828 it != mStreamInfo.end(); it++) {
2829 QCamera3Channel *channel = (QCamera3Channel *)(*it)->stream->priv;
2830 rc = channel->start();
2831 if (rc < 0) {
2832 ALOGE("%s: channel start failed", __func__);
2833 pthread_mutex_unlock(&mMutex);
2834 return rc;
2835 }
2836 }
2837 if (mSupportChannel) {
2838 rc = mSupportChannel->start();
2839 if (rc < 0) {
2840 ALOGE("%s: Support channel start failed", __func__);
2841 pthread_mutex_unlock(&mMutex);
2842 return rc;
2843 }
2844 }
2845 if (mRawDumpChannel) {
2846 rc = mRawDumpChannel->start();
2847 if (rc < 0) {
2848 ALOGE("%s: RAW dump channel start failed", __func__);
2849 pthread_mutex_unlock(&mMutex);
2850 return rc;
2851 }
2852 }
2853
2854 pthread_mutex_unlock(&mMutex);
2855
2856 return 0;
2857 }
2858
2859 /*===========================================================================
2860 * FUNCTION : captureResultCb
2861 *
2862 * DESCRIPTION: Callback handler for all capture result
2863 * (streams, as well as metadata)
2864 *
2865 * PARAMETERS :
2866 * @metadata : metadata information
2867 * @buffer : actual gralloc buffer to be returned to frameworks.
2868 * NULL if metadata.
2869 *
2870 * RETURN : NONE
2871 *==========================================================================*/
captureResultCb(mm_camera_super_buf_t * metadata_buf,camera3_stream_buffer_t * buffer,uint32_t frame_number)2872 void QCamera3HardwareInterface::captureResultCb(mm_camera_super_buf_t *metadata_buf,
2873 camera3_stream_buffer_t *buffer, uint32_t frame_number)
2874 {
2875 pthread_mutex_lock(&mMutex);
2876
2877 /* Assume flush() is called before any reprocessing. Send
2878 * notify and result immediately upon receipt of any callback*/
2879 if (mLoopBackResult) {
2880 /* Send notify */
2881 camera3_notify_msg_t notify_msg;
2882 notify_msg.type = CAMERA3_MSG_SHUTTER;
2883 notify_msg.message.shutter.frame_number = mLoopBackResult->frame_number;
2884 notify_msg.message.shutter.timestamp = mLoopBackTimestamp;
2885 mCallbackOps->notify(mCallbackOps, ¬ify_msg);
2886 /* Send capture result */
2887 mCallbackOps->process_capture_result(mCallbackOps, mLoopBackResult);
2888 free_camera_metadata((camera_metadata_t *)mLoopBackResult->result);
2889 free(mLoopBackResult);
2890 mLoopBackResult = NULL;
2891 }
2892
2893 if (metadata_buf)
2894 handleMetadataWithLock(metadata_buf);
2895 else
2896 handleBufferWithLock(buffer, frame_number);
2897 pthread_mutex_unlock(&mMutex);
2898 }
2899
2900 /*===========================================================================
2901 * FUNCTION : translateFromHalMetadata
2902 *
2903 * DESCRIPTION:
2904 *
2905 * PARAMETERS :
2906 * @metadata : metadata information from callback
2907 * @timestamp: metadata buffer timestamp
2908 * @request_id: request id
2909 * @jpegMetadata: additional jpeg metadata
2910 *
2911 * RETURN : camera_metadata_t*
2912 * metadata in a format specified by fwk
2913 *==========================================================================*/
2914 camera_metadata_t*
translateFromHalMetadata(metadata_buffer_t * metadata,nsecs_t timestamp,int32_t request_id,const CameraMetadata & jpegMetadata,uint8_t pipeline_depth,uint8_t capture_intent)2915 QCamera3HardwareInterface::translateFromHalMetadata(
2916 metadata_buffer_t *metadata,
2917 nsecs_t timestamp,
2918 int32_t request_id,
2919 const CameraMetadata& jpegMetadata,
2920 uint8_t pipeline_depth,
2921 uint8_t capture_intent)
2922 {
2923 CameraMetadata camMetadata;
2924 camera_metadata_t* resultMetadata;
2925
2926 if (jpegMetadata.entryCount())
2927 camMetadata.append(jpegMetadata);
2928
2929 camMetadata.update(ANDROID_SENSOR_TIMESTAMP, ×tamp, 1);
2930 camMetadata.update(ANDROID_REQUEST_ID, &request_id, 1);
2931 camMetadata.update(ANDROID_REQUEST_PIPELINE_DEPTH, &pipeline_depth, 1);
2932 camMetadata.update(ANDROID_CONTROL_CAPTURE_INTENT, &capture_intent, 1);
2933
2934 if (IS_META_AVAILABLE(CAM_INTF_META_FRAME_NUMBER, metadata)) {
2935 int64_t frame_number = *(uint32_t *) POINTER_OF_META(CAM_INTF_META_FRAME_NUMBER, metadata);
2936 camMetadata.update(ANDROID_SYNC_FRAME_NUMBER, &frame_number, 1);
2937 }
2938
2939
2940 if (IS_META_AVAILABLE(CAM_INTF_PARM_FPS_RANGE, metadata)) {
2941 int32_t fps_range[2];
2942 cam_fps_range_t * float_range =
2943 (cam_fps_range_t *)POINTER_OF_PARAM(CAM_INTF_PARM_FPS_RANGE, metadata);
2944 fps_range[0] = (int32_t)float_range->min_fps;
2945 fps_range[1] = (int32_t)float_range->max_fps;
2946 camMetadata.update(ANDROID_CONTROL_AE_TARGET_FPS_RANGE,
2947 fps_range, 2);
2948 CDBG("%s: urgent Metadata : ANDROID_CONTROL_AE_TARGET_FPS_RANGE [%d, %d]",
2949 __func__, fps_range[0], fps_range[1]);
2950 }
2951
2952
2953 if (IS_META_AVAILABLE(CAM_INTF_PARM_EXPOSURE_COMPENSATION, metadata)) {
2954 int32_t *expCompensation =
2955 (int32_t *)POINTER_OF_META(CAM_INTF_PARM_EXPOSURE_COMPENSATION, metadata);
2956 camMetadata.update(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION,
2957 expCompensation, 1);
2958 }
2959
2960 if (IS_META_AVAILABLE(CAM_INTF_PARM_BESTSHOT_MODE, metadata)) {
2961 uint8_t sceneMode =
2962 *((uint32_t *)POINTER_OF_META(CAM_INTF_PARM_BESTSHOT_MODE, metadata));
2963 uint8_t fwkSceneMode =
2964 (uint8_t)lookupFwkName(SCENE_MODES_MAP,
2965 sizeof(SCENE_MODES_MAP)/
2966 sizeof(SCENE_MODES_MAP[0]), sceneMode);
2967 camMetadata.update(ANDROID_CONTROL_SCENE_MODE,
2968 &fwkSceneMode, 1);
2969 }
2970
2971 if (IS_META_AVAILABLE(CAM_INTF_PARM_AEC_LOCK, metadata)) {
2972 uint8_t ae_lock =
2973 *((uint32_t *)POINTER_OF_META(CAM_INTF_PARM_AEC_LOCK, metadata));
2974 camMetadata.update(ANDROID_CONTROL_AE_LOCK,
2975 &ae_lock, 1);
2976 }
2977
2978 if (IS_META_AVAILABLE(CAM_INTF_PARM_AWB_LOCK, metadata)) {
2979 uint8_t awb_lock =
2980 *((uint32_t *)POINTER_OF_META(CAM_INTF_PARM_AWB_LOCK, metadata));
2981 camMetadata.update(ANDROID_CONTROL_AWB_LOCK, &awb_lock, 1);
2982 }
2983
2984 if (IS_META_AVAILABLE(CAM_INTF_META_FACE_DETECTION, metadata)){
2985 cam_face_detection_data_t *faceDetectionInfo =
2986 (cam_face_detection_data_t *)POINTER_OF_META(CAM_INTF_META_FACE_DETECTION, metadata);
2987 uint8_t numFaces = MIN(faceDetectionInfo->num_faces_detected, MAX_ROI);
2988 int32_t faceIds[MAX_ROI];
2989 uint8_t faceScores[MAX_ROI];
2990 int32_t faceRectangles[MAX_ROI * 4];
2991 int32_t faceLandmarks[MAX_ROI * 6];
2992 int j = 0, k = 0;
2993 for (int i = 0; i < numFaces; i++) {
2994 faceIds[i] = faceDetectionInfo->faces[i].face_id;
2995 faceScores[i] = faceDetectionInfo->faces[i].score;
2996 convertToRegions(faceDetectionInfo->faces[i].face_boundary,
2997 faceRectangles+j, -1);
2998 convertLandmarks(faceDetectionInfo->faces[i], faceLandmarks+k);
2999 j+= 4;
3000 k+= 6;
3001 }
3002 if (numFaces <= 0) {
3003 memset(faceIds, 0, sizeof(int32_t) * MAX_ROI);
3004 memset(faceScores, 0, sizeof(uint8_t) * MAX_ROI);
3005 memset(faceRectangles, 0, sizeof(int32_t) * MAX_ROI * 4);
3006 memset(faceLandmarks, 0, sizeof(int32_t) * MAX_ROI * 6);
3007 }
3008 camMetadata.update(ANDROID_STATISTICS_FACE_IDS, faceIds, numFaces);
3009 camMetadata.update(ANDROID_STATISTICS_FACE_SCORES, faceScores, numFaces);
3010 camMetadata.update(ANDROID_STATISTICS_FACE_RECTANGLES,
3011 faceRectangles, numFaces*4);
3012 camMetadata.update(ANDROID_STATISTICS_FACE_LANDMARKS,
3013 faceLandmarks, numFaces*6);
3014 }
3015 if (IS_META_AVAILABLE(CAM_INTF_META_COLOR_CORRECT_MODE, metadata)){
3016 uint8_t *color_correct_mode =
3017 (uint8_t *)POINTER_OF_META(CAM_INTF_META_COLOR_CORRECT_MODE, metadata);
3018 camMetadata.update(ANDROID_COLOR_CORRECTION_MODE, color_correct_mode, 1);
3019 }
3020 if (IS_META_AVAILABLE(CAM_INTF_META_EDGE_MODE, metadata)) {
3021 cam_edge_application_t *edgeApplication =
3022 (cam_edge_application_t *)POINTER_OF_META(CAM_INTF_META_EDGE_MODE, metadata);
3023 uint8_t edgeStrength = (uint8_t)edgeApplication->sharpness;
3024 camMetadata.update(ANDROID_EDGE_MODE, &(edgeApplication->edge_mode), 1);
3025 camMetadata.update(ANDROID_EDGE_STRENGTH, &edgeStrength, 1);
3026 }
3027 if (IS_META_AVAILABLE(CAM_INTF_META_FLASH_POWER, metadata)) {
3028 uint8_t *flashPower =
3029 (uint8_t *)POINTER_OF_META(CAM_INTF_META_FLASH_POWER, metadata);
3030 camMetadata.update(ANDROID_FLASH_FIRING_POWER, flashPower, 1);
3031 }
3032 if (IS_META_AVAILABLE(CAM_INTF_META_FLASH_FIRING_TIME, metadata)) {
3033 int64_t *flashFiringTime =
3034 (int64_t *)POINTER_OF_META(CAM_INTF_META_FLASH_FIRING_TIME, metadata);
3035 camMetadata.update(ANDROID_FLASH_FIRING_TIME, flashFiringTime, 1);
3036 }
3037 if (IS_META_AVAILABLE(CAM_INTF_META_FLASH_STATE, metadata)) {
3038 uint8_t flashState =
3039 *((uint8_t *)POINTER_OF_META(CAM_INTF_META_FLASH_STATE, metadata));
3040 if (!gCamCapability[mCameraId]->flash_available) {
3041 flashState = ANDROID_FLASH_STATE_UNAVAILABLE;
3042 }
3043 camMetadata.update(ANDROID_FLASH_STATE, &flashState, 1);
3044 }
3045 if (IS_META_AVAILABLE(CAM_INTF_META_FLASH_MODE, metadata)){
3046 uint8_t flashMode = *((uint8_t*)
3047 POINTER_OF_META(CAM_INTF_META_FLASH_MODE, metadata));
3048 uint8_t fwk_flashMode = lookupFwkName(FLASH_MODES_MAP,
3049 sizeof(FLASH_MODES_MAP), flashMode);
3050 camMetadata.update(ANDROID_FLASH_MODE, &fwk_flashMode, 1);
3051 }
3052 if (IS_META_AVAILABLE(CAM_INTF_META_HOTPIXEL_MODE, metadata)) {
3053 uint8_t *hotPixelMode =
3054 (uint8_t *)POINTER_OF_META(CAM_INTF_META_HOTPIXEL_MODE, metadata);
3055 camMetadata.update(ANDROID_HOT_PIXEL_MODE, hotPixelMode, 1);
3056 }
3057 if (IS_META_AVAILABLE(CAM_INTF_META_LENS_APERTURE, metadata)){
3058 float *lensAperture =
3059 (float *)POINTER_OF_META(CAM_INTF_META_LENS_APERTURE, metadata);
3060 camMetadata.update(ANDROID_LENS_APERTURE , lensAperture, 1);
3061 }
3062 if (IS_META_AVAILABLE(CAM_INTF_META_LENS_FILTERDENSITY, metadata)) {
3063 float *filterDensity =
3064 (float *)POINTER_OF_META(CAM_INTF_META_LENS_FILTERDENSITY, metadata);
3065 camMetadata.update(ANDROID_LENS_FILTER_DENSITY , filterDensity, 1);
3066 }
3067 if (IS_META_AVAILABLE(CAM_INTF_META_LENS_FOCAL_LENGTH, metadata)){
3068 float *focalLength =
3069 (float *)POINTER_OF_META(CAM_INTF_META_LENS_FOCAL_LENGTH, metadata);
3070 camMetadata.update(ANDROID_LENS_FOCAL_LENGTH, focalLength, 1);
3071 }
3072
3073 if (IS_META_AVAILABLE(CAM_INTF_META_LENS_OPT_STAB_MODE, metadata)) {
3074 uint8_t *opticalStab =
3075 (uint8_t *)POINTER_OF_META(CAM_INTF_META_LENS_OPT_STAB_MODE, metadata);
3076 camMetadata.update(ANDROID_LENS_OPTICAL_STABILIZATION_MODE ,opticalStab, 1);
3077 }
3078 if (IS_META_AVAILABLE(CAM_INTF_PARM_DIS_ENABLE, metadata)) {
3079 uint8_t *vsMode =
3080 (uint8_t *)POINTER_OF_META(CAM_INTF_PARM_DIS_ENABLE, metadata);
3081 camMetadata.update(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE, vsMode, 1);
3082 }
3083
3084 if (IS_META_AVAILABLE(CAM_INTF_META_NOISE_REDUCTION_MODE, metadata)) {
3085 uint8_t *noiseRedMode =
3086 (uint8_t *)POINTER_OF_META(CAM_INTF_META_NOISE_REDUCTION_MODE, metadata);
3087 camMetadata.update(ANDROID_NOISE_REDUCTION_MODE , noiseRedMode, 1);
3088 }
3089 if (IS_META_AVAILABLE(CAM_INTF_META_NOISE_REDUCTION_STRENGTH, metadata)) {
3090 uint8_t *noiseRedStrength =
3091 (uint8_t *)POINTER_OF_META(CAM_INTF_META_NOISE_REDUCTION_STRENGTH, metadata);
3092 camMetadata.update(ANDROID_NOISE_REDUCTION_STRENGTH, noiseRedStrength, 1);
3093 }
3094 if (IS_META_AVAILABLE(CAM_INTF_META_EFFECTIVE_EXPOSURE_FACTOR, metadata)) {
3095 float *effectiveExposureFactor =
3096 (float *)POINTER_OF_META(CAM_INTF_META_EFFECTIVE_EXPOSURE_FACTOR, metadata);
3097 camMetadata.update(ANDROID_REPROCESS_EFFECTIVE_EXPOSURE_FACTOR, effectiveExposureFactor, 1);
3098 }
3099 if (IS_META_AVAILABLE(CAM_INTF_META_SCALER_CROP_REGION, metadata)) {
3100 cam_crop_region_t *hScalerCropRegion =(cam_crop_region_t *)
3101 POINTER_OF_META(CAM_INTF_META_SCALER_CROP_REGION, metadata);
3102 int32_t scalerCropRegion[4];
3103 scalerCropRegion[0] = hScalerCropRegion->left;
3104 scalerCropRegion[1] = hScalerCropRegion->top;
3105 scalerCropRegion[2] = hScalerCropRegion->width;
3106 scalerCropRegion[3] = hScalerCropRegion->height;
3107 camMetadata.update(ANDROID_SCALER_CROP_REGION, scalerCropRegion, 4);
3108 }
3109 if (IS_META_AVAILABLE(CAM_INTF_META_SENSOR_EXPOSURE_TIME, metadata)){
3110 int64_t *sensorExpTime =
3111 (int64_t *)POINTER_OF_META(CAM_INTF_META_SENSOR_EXPOSURE_TIME, metadata);
3112 CDBG("%s: sensorExpTime = %lld", __func__, *sensorExpTime);
3113 camMetadata.update(ANDROID_SENSOR_EXPOSURE_TIME , sensorExpTime, 1);
3114 }
3115 if (IS_META_AVAILABLE(CAM_INTF_META_SENSOR_FRAME_DURATION, metadata)){
3116 int64_t *sensorFameDuration =
3117 (int64_t *)POINTER_OF_META(CAM_INTF_META_SENSOR_FRAME_DURATION, metadata);
3118 CDBG("%s: sensorFameDuration = %lld", __func__, *sensorFameDuration);
3119 camMetadata.update(ANDROID_SENSOR_FRAME_DURATION, sensorFameDuration, 1);
3120 }
3121 if (IS_META_AVAILABLE(CAM_INTF_META_SENSOR_ROLLING_SHUTTER_SKEW, metadata)){
3122 int64_t *sensorRollingShutterSkew =
3123 (int64_t *)POINTER_OF_META(CAM_INTF_META_SENSOR_ROLLING_SHUTTER_SKEW,
3124 metadata);
3125 CDBG("%s: sensorRollingShutterSkew = %lld", __func__, *sensorRollingShutterSkew);
3126 camMetadata.update(ANDROID_SENSOR_ROLLING_SHUTTER_SKEW,
3127 sensorRollingShutterSkew, 1);
3128 }
3129
3130 if (IS_META_AVAILABLE(CAM_INTF_META_SENSOR_SENSITIVITY, metadata)){
3131 int32_t sensorSensitivity =
3132 *((int32_t *)POINTER_OF_META(CAM_INTF_META_SENSOR_SENSITIVITY, metadata));
3133 CDBG("%s: sensorSensitivity = %d", __func__, sensorSensitivity);
3134 camMetadata.update(ANDROID_SENSOR_SENSITIVITY, &sensorSensitivity, 1);
3135
3136 //calculate the noise profile based on sensitivity
3137 double noise_profile_S = computeNoiseModelEntryS(sensorSensitivity);
3138 double noise_profile_O = computeNoiseModelEntryO(sensorSensitivity);
3139 double noise_profile[2 * gCamCapability[mCameraId]->num_color_channels];
3140 for (int i = 0; i < 2 * gCamCapability[mCameraId]->num_color_channels; i +=2) {
3141 noise_profile[i] = noise_profile_S;
3142 noise_profile[i+1] = noise_profile_O;
3143 }
3144 CDBG("%s: noise model entry (S, O) is (%f, %f)", __func__,
3145 noise_profile_S, noise_profile_O);
3146 camMetadata.update( ANDROID_SENSOR_NOISE_PROFILE, noise_profile,
3147 2 * gCamCapability[mCameraId]->num_color_channels);
3148 }
3149
3150
3151 if (IS_META_AVAILABLE(CAM_INTF_META_SHADING_MODE, metadata)) {
3152 uint8_t *shadingMode =
3153 (uint8_t *)POINTER_OF_META(CAM_INTF_META_SHADING_MODE, metadata);
3154 camMetadata.update(ANDROID_SHADING_MODE, shadingMode, 1);
3155 }
3156 if (IS_META_AVAILABLE(CAM_INTF_META_STATS_FACEDETECT_MODE, metadata)) {
3157 uint8_t *faceDetectMode =
3158 (uint8_t *)POINTER_OF_META(CAM_INTF_META_STATS_FACEDETECT_MODE, metadata);
3159 uint8_t fwk_faceDetectMode = (uint8_t)lookupFwkName(FACEDETECT_MODES_MAP,
3160 sizeof(FACEDETECT_MODES_MAP)/sizeof(FACEDETECT_MODES_MAP[0]), *faceDetectMode);
3161 camMetadata.update(ANDROID_STATISTICS_FACE_DETECT_MODE, &fwk_faceDetectMode, 1);
3162 }
3163 if (IS_META_AVAILABLE(CAM_INTF_META_STATS_HISTOGRAM_MODE, metadata)) {
3164 uint8_t *histogramMode =
3165 (uint8_t *)POINTER_OF_META(CAM_INTF_META_STATS_HISTOGRAM_MODE, metadata);
3166 camMetadata.update(ANDROID_STATISTICS_HISTOGRAM_MODE, histogramMode, 1);
3167 }
3168 if (IS_META_AVAILABLE(CAM_INTF_META_STATS_SHARPNESS_MAP_MODE, metadata)){
3169 uint8_t *sharpnessMapMode =
3170 (uint8_t *)POINTER_OF_META(CAM_INTF_META_STATS_SHARPNESS_MAP_MODE, metadata);
3171 camMetadata.update(ANDROID_STATISTICS_SHARPNESS_MAP_MODE,
3172 sharpnessMapMode, 1);
3173 }
3174 if (IS_META_AVAILABLE(CAM_INTF_META_STATS_SHARPNESS_MAP, metadata)){
3175 cam_sharpness_map_t *sharpnessMap = (cam_sharpness_map_t *)
3176 POINTER_OF_META(CAM_INTF_META_STATS_SHARPNESS_MAP, metadata);
3177 camMetadata.update(ANDROID_STATISTICS_SHARPNESS_MAP,
3178 (int32_t*)sharpnessMap->sharpness,
3179 CAM_MAX_MAP_WIDTH*CAM_MAX_MAP_HEIGHT);
3180 }
3181 if (IS_META_AVAILABLE(CAM_INTF_META_LENS_SHADING_MAP, metadata)) {
3182 cam_lens_shading_map_t *lensShadingMap = (cam_lens_shading_map_t *)
3183 POINTER_OF_META(CAM_INTF_META_LENS_SHADING_MAP, metadata);
3184 int map_height = gCamCapability[mCameraId]->lens_shading_map_size.height;
3185 int map_width = gCamCapability[mCameraId]->lens_shading_map_size.width;
3186 camMetadata.update(ANDROID_STATISTICS_LENS_SHADING_MAP,
3187 (float*)lensShadingMap->lens_shading,
3188 4*map_width*map_height);
3189 }
3190 if (IS_META_AVAILABLE(CAM_INTF_META_TONEMAP_MODE, metadata)) {
3191 uint8_t *toneMapMode =
3192 (uint8_t *)POINTER_OF_META(CAM_INTF_META_TONEMAP_MODE, metadata);
3193 camMetadata.update(ANDROID_TONEMAP_MODE, toneMapMode, 1);
3194 }
3195 if (IS_META_AVAILABLE(CAM_INTF_META_TONEMAP_CURVES, metadata)){
3196 //Populate CAM_INTF_META_TONEMAP_CURVES
3197 /* ch0 = G, ch 1 = B, ch 2 = R*/
3198 cam_rgb_tonemap_curves *tonemap = (cam_rgb_tonemap_curves *)
3199 POINTER_OF_META(CAM_INTF_META_TONEMAP_CURVES, metadata);
3200 if (tonemap->tonemap_points_cnt > CAM_MAX_TONEMAP_CURVE_SIZE) {
3201 ALOGE("%s: Fatal: tonemap_points_cnt %d exceeds max value of %d",
3202 __func__, tonemap->tonemap_points_cnt,
3203 CAM_MAX_TONEMAP_CURVE_SIZE);
3204 tonemap->tonemap_points_cnt = CAM_MAX_TONEMAP_CURVE_SIZE;
3205 }
3206
3207 camMetadata.update(ANDROID_TONEMAP_CURVE_GREEN,
3208 (float*)tonemap->curves[0].tonemap_points,
3209 tonemap->tonemap_points_cnt * 2);
3210
3211 camMetadata.update(ANDROID_TONEMAP_CURVE_BLUE,
3212 (float*)tonemap->curves[1].tonemap_points,
3213 tonemap->tonemap_points_cnt * 2);
3214
3215 camMetadata.update(ANDROID_TONEMAP_CURVE_RED,
3216 (float*)tonemap->curves[2].tonemap_points,
3217 tonemap->tonemap_points_cnt * 2);
3218 }
3219 if (IS_META_AVAILABLE(CAM_INTF_META_COLOR_CORRECT_GAINS, metadata)){
3220 cam_color_correct_gains_t *colorCorrectionGains = (cam_color_correct_gains_t*)
3221 POINTER_OF_META(CAM_INTF_META_COLOR_CORRECT_GAINS, metadata);
3222 camMetadata.update(ANDROID_COLOR_CORRECTION_GAINS, colorCorrectionGains->gains, 4);
3223 }
3224 if (IS_META_AVAILABLE(CAM_INTF_META_COLOR_CORRECT_TRANSFORM, metadata)){
3225 cam_color_correct_matrix_t *colorCorrectionMatrix = (cam_color_correct_matrix_t*)
3226 POINTER_OF_META(CAM_INTF_META_COLOR_CORRECT_TRANSFORM, metadata);
3227 camMetadata.update(ANDROID_COLOR_CORRECTION_TRANSFORM,
3228 (camera_metadata_rational_t*)colorCorrectionMatrix->transform_matrix, 3*3);
3229 }
3230 if (IS_META_AVAILABLE(CAM_INTF_META_PROFILE_TONE_CURVE, metadata)) {
3231 cam_profile_tone_curve *toneCurve = (cam_profile_tone_curve *)
3232 POINTER_OF_META(CAM_INTF_META_PROFILE_TONE_CURVE, metadata);
3233 if (toneCurve->tonemap_points_cnt > CAM_MAX_TONEMAP_CURVE_SIZE) {
3234 ALOGE("%s: Fatal: tonemap_points_cnt %d exceeds max value of %d",
3235 __func__, toneCurve->tonemap_points_cnt,
3236 CAM_MAX_TONEMAP_CURVE_SIZE);
3237 toneCurve->tonemap_points_cnt = CAM_MAX_TONEMAP_CURVE_SIZE;
3238 }
3239 camMetadata.update(ANDROID_SENSOR_PROFILE_TONE_CURVE,
3240 (float*)toneCurve->curve.tonemap_points,
3241 toneCurve->tonemap_points_cnt * 2);
3242 }
3243 if (IS_META_AVAILABLE(CAM_INTF_META_PRED_COLOR_CORRECT_GAINS, metadata)){
3244 cam_color_correct_gains_t *predColorCorrectionGains = (cam_color_correct_gains_t*)
3245 POINTER_OF_META(CAM_INTF_META_PRED_COLOR_CORRECT_GAINS, metadata);
3246 camMetadata.update(ANDROID_STATISTICS_PREDICTED_COLOR_GAINS,
3247 predColorCorrectionGains->gains, 4);
3248 }
3249 if (IS_META_AVAILABLE(CAM_INTF_META_PRED_COLOR_CORRECT_TRANSFORM, metadata)){
3250 cam_color_correct_matrix_t *predColorCorrectionMatrix = (cam_color_correct_matrix_t*)
3251 POINTER_OF_META(CAM_INTF_META_PRED_COLOR_CORRECT_TRANSFORM, metadata);
3252 camMetadata.update(ANDROID_STATISTICS_PREDICTED_COLOR_TRANSFORM,
3253 (camera_metadata_rational_t*)predColorCorrectionMatrix->transform_matrix, 3*3);
3254 }
3255 if (IS_META_AVAILABLE(CAM_INTF_META_OTP_WB_GRGB, metadata)) {
3256 float *otpWbGrGb = (float*) POINTER_OF_META(
3257 CAM_INTF_META_OTP_WB_GRGB, metadata);
3258 camMetadata.update(ANDROID_SENSOR_GREEN_SPLIT, otpWbGrGb, 1);
3259 }
3260 if (IS_META_AVAILABLE(CAM_INTF_META_BLACK_LEVEL_LOCK, metadata)){
3261 uint8_t *blackLevelLock = (uint8_t*)
3262 POINTER_OF_META(CAM_INTF_META_BLACK_LEVEL_LOCK, metadata);
3263 camMetadata.update(ANDROID_BLACK_LEVEL_LOCK, blackLevelLock, 1);
3264 }
3265 if (IS_META_AVAILABLE(CAM_INTF_META_SCENE_FLICKER, metadata)){
3266 uint8_t *sceneFlicker = (uint8_t*)
3267 POINTER_OF_META(CAM_INTF_META_SCENE_FLICKER, metadata);
3268 camMetadata.update(ANDROID_STATISTICS_SCENE_FLICKER, sceneFlicker, 1);
3269 }
3270 if (IS_META_AVAILABLE(CAM_INTF_PARM_EFFECT, metadata)) {
3271 uint8_t *effectMode = (uint8_t*)
3272 POINTER_OF_META(CAM_INTF_PARM_EFFECT, metadata);
3273 uint8_t fwk_effectMode = (uint8_t)lookupFwkName(EFFECT_MODES_MAP,
3274 sizeof(EFFECT_MODES_MAP),
3275 *effectMode);
3276 camMetadata.update(ANDROID_CONTROL_EFFECT_MODE, &fwk_effectMode, 1);
3277 }
3278 if (IS_META_AVAILABLE(CAM_INTF_META_TEST_PATTERN_DATA, metadata)) {
3279 cam_test_pattern_data_t *testPatternData = (cam_test_pattern_data_t *)
3280 POINTER_OF_META(CAM_INTF_META_TEST_PATTERN_DATA, metadata);
3281 int32_t fwk_testPatternMode = lookupFwkName(TEST_PATTERN_MAP,
3282 sizeof(TEST_PATTERN_MAP)/sizeof(TEST_PATTERN_MAP[0]),
3283 testPatternData->mode);
3284 camMetadata.update(ANDROID_SENSOR_TEST_PATTERN_MODE,
3285 &fwk_testPatternMode, 1);
3286 int32_t fwk_testPatternData[4];
3287 fwk_testPatternData[0] = testPatternData->r;
3288 fwk_testPatternData[3] = testPatternData->b;
3289 switch (gCamCapability[mCameraId]->color_arrangement) {
3290 case CAM_FILTER_ARRANGEMENT_RGGB:
3291 case CAM_FILTER_ARRANGEMENT_GRBG:
3292 fwk_testPatternData[1] = testPatternData->gr;
3293 fwk_testPatternData[2] = testPatternData->gb;
3294 break;
3295 case CAM_FILTER_ARRANGEMENT_GBRG:
3296 case CAM_FILTER_ARRANGEMENT_BGGR:
3297 fwk_testPatternData[2] = testPatternData->gr;
3298 fwk_testPatternData[1] = testPatternData->gb;
3299 break;
3300 default:
3301 ALOGE("%s: color arrangement %d is not supported", __func__,
3302 gCamCapability[mCameraId]->color_arrangement);
3303 break;
3304 }
3305 camMetadata.update(ANDROID_SENSOR_TEST_PATTERN_DATA, fwk_testPatternData, 4);
3306 }
3307 if (IS_META_AVAILABLE(CAM_INTF_META_JPEG_GPS_COORDINATES, metadata)) {
3308 double *gps_coords = (double *)POINTER_OF_META(
3309 CAM_INTF_META_JPEG_GPS_COORDINATES, metadata);
3310 camMetadata.update(ANDROID_JPEG_GPS_COORDINATES, gps_coords, 3);
3311 }
3312 if (IS_META_AVAILABLE(CAM_INTF_META_JPEG_GPS_PROC_METHODS, metadata)) {
3313 char *gps_methods = (char *)POINTER_OF_META(
3314 CAM_INTF_META_JPEG_GPS_PROC_METHODS, metadata);
3315 String8 str(gps_methods);
3316 camMetadata.update(ANDROID_JPEG_GPS_PROCESSING_METHOD, str);
3317 }
3318 if (IS_META_AVAILABLE(CAM_INTF_META_JPEG_GPS_TIMESTAMP, metadata)) {
3319 int64_t *gps_timestamp = (int64_t *)POINTER_OF_META(
3320 CAM_INTF_META_JPEG_GPS_TIMESTAMP, metadata);
3321 camMetadata.update(ANDROID_JPEG_GPS_TIMESTAMP, gps_timestamp, 1);
3322 }
3323 if (IS_META_AVAILABLE(CAM_INTF_META_JPEG_ORIENTATION, metadata)) {
3324 int32_t *jpeg_orientation = (int32_t *)POINTER_OF_META(
3325 CAM_INTF_META_JPEG_ORIENTATION, metadata);
3326 camMetadata.update(ANDROID_JPEG_ORIENTATION, jpeg_orientation, 1);
3327 }
3328 if (IS_META_AVAILABLE(CAM_INTF_META_JPEG_QUALITY, metadata)) {
3329 uint8_t *jpeg_quality = (uint8_t *)POINTER_OF_META(
3330 CAM_INTF_META_JPEG_QUALITY, metadata);
3331 camMetadata.update(ANDROID_JPEG_QUALITY, jpeg_quality, 1);
3332 }
3333 if (IS_META_AVAILABLE(CAM_INTF_META_JPEG_THUMB_QUALITY, metadata)) {
3334 uint8_t *thumb_quality = (uint8_t *)POINTER_OF_META(
3335 CAM_INTF_META_JPEG_THUMB_QUALITY, metadata);
3336 camMetadata.update(ANDROID_JPEG_THUMBNAIL_QUALITY, thumb_quality, 1);
3337 }
3338 if (IS_META_AVAILABLE(CAM_INTF_META_JPEG_THUMB_SIZE, metadata)) {
3339 cam_dimension_t *thumb_size = (cam_dimension_t *)POINTER_OF_META(
3340 CAM_INTF_META_JPEG_THUMB_SIZE, metadata);
3341 // Note: cam_dimension_t should have the right layout, but for safety just copy it.
3342 int32_t thumbnail_size[2];
3343 thumbnail_size[0] = thumb_size->width;
3344 thumbnail_size[1] = thumb_size->height;
3345 camMetadata.update(ANDROID_JPEG_THUMBNAIL_SIZE, thumbnail_size, 2);
3346 }
3347 if (IS_META_AVAILABLE(CAM_INTF_META_PRIVATE_DATA, metadata)) {
3348 int32_t *privateData = (int32_t *)
3349 POINTER_OF_META(CAM_INTF_META_PRIVATE_DATA, metadata);
3350 camMetadata.update(QCAMERA3_PRIVATEDATA_REPROCESS,
3351 privateData, MAX_METADATA_PRIVATE_PAYLOAD_SIZE);
3352 }
3353 if (metadata->is_tuning_params_valid) {
3354 uint8_t tuning_meta_data_blob[sizeof(tuning_params_t)];
3355 uint8_t *data = (uint8_t*)&tuning_meta_data_blob[0];
3356 metadata->tuning_params.tuning_data_version = TUNING_DATA_VERSION;
3357
3358
3359 memcpy(data, ((uint8_t*)&metadata->tuning_params.tuning_data_version),
3360 sizeof(uint32_t));
3361 data += sizeof(uint32_t);
3362
3363 memcpy(data, ((uint8_t*)&metadata->tuning_params.tuning_sensor_data_size),
3364 sizeof(uint32_t));
3365 CDBG("tuning_sensor_data_size %d",(int)(*(int *)data));
3366 data += sizeof(uint32_t);
3367
3368 memcpy(data, ((uint8_t *)&metadata->tuning_params.tuning_vfe_data_size),
3369 sizeof(uint32_t));
3370 CDBG("tuning_vfe_data_size %d",(int)(*(int *)data));
3371 data += sizeof(uint32_t);
3372
3373 memcpy(data, ((uint8_t *)&metadata->tuning_params.tuning_cpp_data_size),
3374 sizeof(uint32_t));
3375 CDBG("tuning_cpp_data_size %d",(int)(*(int *)data));
3376 data += sizeof(uint32_t);
3377
3378 memcpy(data, ((uint8_t *)&metadata->tuning_params.tuning_cac_data_size),
3379 sizeof(uint32_t));
3380 CDBG("tuning_cac_data_size %d",(int)(*(int *)data));
3381 data += sizeof(uint32_t);
3382
3383 metadata->tuning_params.tuning_mod3_data_size = 0;
3384 memcpy(data, ((uint8_t *)&metadata->tuning_params.tuning_mod3_data_size),
3385 sizeof(uint32_t));
3386 CDBG("tuning_mod3_data_size %d",(int)(*(int *)data));
3387 data += sizeof(uint32_t);
3388
3389 memcpy(data, ((uint8_t *)&metadata->tuning_params.data),
3390 metadata->tuning_params.tuning_sensor_data_size);
3391 data += metadata->tuning_params.tuning_sensor_data_size;
3392
3393 memcpy(data, ((uint8_t *)&metadata->tuning_params.data[TUNING_VFE_DATA_OFFSET]),
3394 metadata->tuning_params.tuning_vfe_data_size);
3395 data += metadata->tuning_params.tuning_vfe_data_size;
3396
3397 memcpy(data, ((uint8_t *)&metadata->tuning_params.data[TUNING_CPP_DATA_OFFSET]),
3398 metadata->tuning_params.tuning_cpp_data_size);
3399 data += metadata->tuning_params.tuning_cpp_data_size;
3400
3401
3402 memcpy(data, ((uint8_t *)&metadata->tuning_params.data[TUNING_CAC_DATA_OFFSET]),
3403 metadata->tuning_params.tuning_cac_data_size);
3404 data += metadata->tuning_params.tuning_cac_data_size;
3405
3406 camMetadata.update(QCAMERA3_TUNING_META_DATA_BLOB,
3407 (int32_t*)tuning_meta_data_blob, (data-tuning_meta_data_blob)/sizeof(uint32_t));
3408 }
3409 if (IS_META_AVAILABLE(CAM_INTF_META_NEUTRAL_COL_POINT, metadata)) {
3410 cam_neutral_col_point_t *neuColPoint = (cam_neutral_col_point_t*)
3411 POINTER_OF_META(CAM_INTF_META_NEUTRAL_COL_POINT, metadata);
3412 camMetadata.update(ANDROID_SENSOR_NEUTRAL_COLOR_POINT,
3413 (camera_metadata_rational_t*)neuColPoint->neutral_col_point, 3);
3414 }
3415
3416 if (IS_META_AVAILABLE(CAM_INTF_META_LENS_SHADING_MAP_MODE, metadata)) {
3417 uint8_t shadingMapMode =
3418 *((uint32_t *)POINTER_OF_META(CAM_INTF_META_LENS_SHADING_MAP_MODE, metadata));
3419 camMetadata.update(ANDROID_STATISTICS_LENS_SHADING_MAP_MODE, &shadingMapMode, 1);
3420 }
3421
3422 if (IS_META_AVAILABLE(CAM_INTF_META_AEC_ROI, metadata)) {
3423 cam_area_t *hAeRegions =
3424 (cam_area_t *)POINTER_OF_META(CAM_INTF_META_AEC_ROI, metadata);
3425 int32_t aeRegions[5];
3426 convertToRegions(hAeRegions->rect, aeRegions, hAeRegions->weight);
3427 camMetadata.update(ANDROID_CONTROL_AE_REGIONS, aeRegions, 5);
3428 CDBG("%s: Metadata : ANDROID_CONTROL_AE_REGIONS: FWK: [%d,%d,%d,%d] HAL: [%d,%d,%d,%d]",
3429 __func__, aeRegions[0], aeRegions[1], aeRegions[2], aeRegions[3],
3430 hAeRegions->rect.left, hAeRegions->rect.top, hAeRegions->rect.width,
3431 hAeRegions->rect.height);
3432 }
3433
3434 if (IS_META_AVAILABLE(CAM_INTF_META_AF_ROI, metadata)) {
3435 /*af regions*/
3436 cam_area_t *hAfRegions =
3437 (cam_area_t *)POINTER_OF_META(CAM_INTF_META_AF_ROI, metadata);
3438 int32_t afRegions[5];
3439 convertToRegions(hAfRegions->rect, afRegions, hAfRegions->weight);
3440 camMetadata.update(ANDROID_CONTROL_AF_REGIONS, afRegions, 5);
3441 CDBG("%s: Metadata : ANDROID_CONTROL_AF_REGIONS: FWK: [%d,%d,%d,%d] HAL: [%d,%d,%d,%d]",
3442 __func__, afRegions[0], afRegions[1], afRegions[2], afRegions[3],
3443 hAfRegions->rect.left, hAfRegions->rect.top, hAfRegions->rect.width,
3444 hAfRegions->rect.height);
3445 }
3446
3447 if (IS_META_AVAILABLE(CAM_INTF_PARM_ANTIBANDING, metadata)) {
3448 uint8_t hal_ab_mode =
3449 *((uint32_t *)POINTER_OF_META(CAM_INTF_PARM_ANTIBANDING, metadata));
3450 uint8_t fwk_ab_mode = (uint8_t)lookupFwkName(ANTIBANDING_MODES_MAP,
3451 sizeof(ANTIBANDING_MODES_MAP)/sizeof(ANTIBANDING_MODES_MAP[0]),
3452 hal_ab_mode);
3453 camMetadata.update(ANDROID_CONTROL_AE_ANTIBANDING_MODE,
3454 &fwk_ab_mode, 1);
3455 }
3456
3457 if (IS_META_AVAILABLE(CAM_INTF_META_MODE, metadata)) {
3458 uint8_t mode =
3459 *((uint32_t *)POINTER_OF_META(CAM_INTF_META_MODE, metadata));
3460 camMetadata.update(ANDROID_CONTROL_MODE, &mode, 1);
3461 }
3462
3463 /* Constant metadata values to be update*/
3464 uint8_t hotPixelMode = ANDROID_HOT_PIXEL_MODE_FAST;
3465 camMetadata.update(ANDROID_HOT_PIXEL_MODE, &hotPixelMode, 1);
3466
3467 uint8_t hotPixelMapMode = ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE_OFF;
3468 camMetadata.update(ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE, &hotPixelMapMode, 1);
3469
3470 int32_t hotPixelMap[2];
3471 camMetadata.update(ANDROID_STATISTICS_HOT_PIXEL_MAP, &hotPixelMap[0], 0);
3472
3473 uint8_t vsMode = ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF;
3474 camMetadata.update(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE, &vsMode, 1);
3475
3476 // CDS
3477 if (IS_META_AVAILABLE(CAM_INTF_PARM_CDS_MODE, metadata)) {
3478 cam_cds_mode_type_t *cds = (cam_cds_mode_type_t *)
3479 POINTER_OF_META(CAM_INTF_PARM_CDS_MODE, metadata);
3480 int32_t mode = *cds;
3481 camMetadata.update(QCAMERA3_CDS_MODE,
3482 &mode, 1);
3483 }
3484
3485 // Reprocess crop data
3486 if (IS_META_AVAILABLE(CAM_INTF_META_CROP_DATA, metadata)) {
3487 cam_crop_data_t *crop_data = (cam_crop_data_t *)
3488 POINTER_OF_PARAM(CAM_INTF_META_CROP_DATA, metadata);
3489 uint8_t cnt = crop_data->num_of_streams;
3490 if ((0 < cnt) && (cnt < MAX_NUM_STREAMS)) {
3491 int rc = NO_ERROR;
3492 int32_t *crop = new int32_t[cnt*4];
3493 if (NULL == crop) {
3494 rc = NO_MEMORY;
3495 }
3496
3497 int32_t *crop_stream_ids = new int32_t[cnt];
3498 if (NULL == crop_stream_ids) {
3499 rc = NO_MEMORY;
3500 }
3501
3502 if (NO_ERROR == rc) {
3503 int32_t steams_found = 0;
3504 for (size_t i = 0; i < cnt; i++) {
3505 for (List<stream_info_t *>::iterator it = mStreamInfo.begin();
3506 it != mStreamInfo.end(); it++) {
3507 QCamera3Channel *channel = (QCamera3Channel *)(*it)->stream->priv;
3508 if (NULL != channel) {
3509 if (crop_data->crop_info[i].stream_id ==
3510 channel->mStreams[0]->getMyServerID()) {
3511 crop[steams_found*4] = crop_data->crop_info[i].crop.left;
3512 crop[steams_found*4 + 1] = crop_data->crop_info[i].crop.top;
3513 crop[steams_found*4 + 2] = crop_data->crop_info[i].crop.width;
3514 crop[steams_found*4 + 3] = crop_data->crop_info[i].crop.height;
3515 // In a more general case we may want to generate
3516 // unique id depending on width, height, stream, private
3517 // data etc.
3518 crop_stream_ids[steams_found] = (int32_t)(*it)->stream;
3519 steams_found++;
3520 CDBG("%s: Adding reprocess crop data for stream %p %dx%d, %dx%d",
3521 __func__,
3522 (*it)->stream,
3523 crop_data->crop_info[i].crop.left,
3524 crop_data->crop_info[i].crop.top,
3525 crop_data->crop_info[i].crop.width,
3526 crop_data->crop_info[i].crop.height);
3527 break;
3528 }
3529 }
3530 }
3531 }
3532
3533 camMetadata.update(QCAMERA3_CROP_COUNT_REPROCESS,
3534 &steams_found, 1);
3535 camMetadata.update(QCAMERA3_CROP_REPROCESS,
3536 crop, steams_found*4);
3537 camMetadata.update(QCAMERA3_CROP_STREAM_ID_REPROCESS,
3538 crop_stream_ids, steams_found);
3539 }
3540
3541 if (crop) {
3542 delete [] crop;
3543 }
3544 if (crop_stream_ids) {
3545 delete [] crop_stream_ids;
3546 }
3547 } else {
3548 // mm-qcamera-daemon only posts crop_data for streams
3549 // not linked to pproc. So no valid crop metadata is not
3550 // necessarily an error case.
3551 CDBG("%s: No valid crop metadata entries", __func__);
3552 }
3553 }
3554
3555 if (IS_PARAM_AVAILABLE(CAM_INTF_PARM_CAC, metadata)) {
3556 cam_aberration_mode_t *cacMode = (cam_aberration_mode_t *)
3557 POINTER_OF_PARAM(CAM_INTF_PARM_CAC, metadata);
3558 int32_t cac = lookupFwkName(COLOR_ABERRATION_MAP,
3559 sizeof(COLOR_ABERRATION_MAP)/sizeof(COLOR_ABERRATION_MAP[0]),
3560 *cacMode);
3561 if (NAME_NOT_FOUND != cac) {
3562 uint8_t val = (uint8_t) cac;
3563 camMetadata.update(ANDROID_COLOR_CORRECTION_ABERRATION_MODE,
3564 &val,
3565 1);
3566 } else {
3567 ALOGE("%s: Invalid CAC camera parameter: %d", __func__, *cacMode);
3568 }
3569 }
3570
3571 resultMetadata = camMetadata.release();
3572 return resultMetadata;
3573 }
3574
3575 /*===========================================================================
3576 * FUNCTION : translateCbUrgentMetadataToResultMetadata
3577 *
3578 * DESCRIPTION:
3579 *
3580 * PARAMETERS :
3581 * @metadata : metadata information from callback
3582 *
3583 * RETURN : camera_metadata_t*
3584 * metadata in a format specified by fwk
3585 *==========================================================================*/
3586 camera_metadata_t*
translateCbUrgentMetadataToResultMetadata(metadata_buffer_t * metadata)3587 QCamera3HardwareInterface::translateCbUrgentMetadataToResultMetadata
3588 (metadata_buffer_t *metadata)
3589 {
3590 CameraMetadata camMetadata;
3591 camera_metadata_t* resultMetadata;
3592 uint8_t aeMode = CAM_AE_MODE_MAX;
3593 int32_t *flashMode = NULL;
3594 int32_t *redeye = NULL;
3595
3596 if (IS_META_AVAILABLE(CAM_INTF_META_AEC_STATE, metadata)) {
3597 uint8_t *ae_state = (uint8_t *)
3598 POINTER_OF_META(CAM_INTF_META_AEC_STATE, metadata);
3599 camMetadata.update(ANDROID_CONTROL_AE_STATE, ae_state, 1);
3600 CDBG("%s: urgent Metadata : ANDROID_CONTROL_AE_STATE", __func__);
3601 }
3602
3603 if (IS_META_AVAILABLE(CAM_INTF_META_AF_STATE, metadata)) {
3604 uint8_t *afState = (uint8_t *)
3605 POINTER_OF_META(CAM_INTF_META_AF_STATE, metadata);
3606 camMetadata.update(ANDROID_CONTROL_AF_STATE, afState, 1);
3607 CDBG("%s: urgent Metadata : ANDROID_CONTROL_AF_STATE %d", __func__, *afState);
3608 }
3609
3610 if (IS_META_AVAILABLE(CAM_INTF_META_LENS_FOCUS_DISTANCE, metadata)) {
3611 float *focusDistance =
3612 (float *)POINTER_OF_META(CAM_INTF_META_LENS_FOCUS_DISTANCE, metadata);
3613 camMetadata.update(ANDROID_LENS_FOCUS_DISTANCE , focusDistance, 1);
3614 }
3615
3616 if (IS_META_AVAILABLE(CAM_INTF_META_LENS_FOCUS_RANGE, metadata)) {
3617 float *focusRange =
3618 (float *)POINTER_OF_META(CAM_INTF_META_LENS_FOCUS_RANGE, metadata);
3619 camMetadata.update(ANDROID_LENS_FOCUS_RANGE , focusRange, 2);
3620 }
3621
3622 if (IS_META_AVAILABLE(CAM_INTF_META_AWB_STATE, metadata)) {
3623 uint8_t *whiteBalanceState = (uint8_t *)
3624 POINTER_OF_META(CAM_INTF_META_AWB_STATE, metadata);
3625 camMetadata.update(ANDROID_CONTROL_AWB_STATE, whiteBalanceState, 1);
3626 CDBG("%s: urgent Metadata : ANDROID_CONTROL_AWB_STATE", __func__);
3627 }
3628
3629 if (IS_META_AVAILABLE(CAM_INTF_META_AEC_PRECAPTURE_TRIGGER, metadata)) {
3630 cam_trigger_t *aecTrigger =
3631 (cam_trigger_t *)POINTER_OF_META(CAM_INTF_META_AEC_PRECAPTURE_TRIGGER, metadata);
3632 camMetadata.update(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER,
3633 &aecTrigger->trigger, 1);
3634 camMetadata.update(ANDROID_CONTROL_AE_PRECAPTURE_ID,
3635 &aecTrigger->trigger_id, 1);
3636 }
3637
3638 if (IS_META_AVAILABLE(CAM_INTF_PARM_FOCUS_MODE, metadata)) {
3639 uint8_t *focusMode = (uint8_t *)
3640 POINTER_OF_META(CAM_INTF_PARM_FOCUS_MODE, metadata);
3641 uint8_t fwkAfMode = (uint8_t)lookupFwkName(FOCUS_MODES_MAP,
3642 sizeof(FOCUS_MODES_MAP)/sizeof(FOCUS_MODES_MAP[0]), *focusMode);
3643 camMetadata.update(ANDROID_CONTROL_AF_MODE, &fwkAfMode, 1);
3644 }
3645
3646 if (IS_META_AVAILABLE(CAM_INTF_META_AF_TRIGGER, metadata)) {
3647 cam_trigger_t *af_trigger =
3648 (cam_trigger_t *)POINTER_OF_META(CAM_INTF_META_AF_TRIGGER, metadata);
3649 camMetadata.update(ANDROID_CONTROL_AF_TRIGGER,
3650 &af_trigger->trigger, 1);
3651 camMetadata.update(ANDROID_CONTROL_AF_TRIGGER_ID, &af_trigger->trigger_id, 1);
3652 }
3653
3654 if (IS_META_AVAILABLE(CAM_INTF_PARM_WHITE_BALANCE, metadata)) {
3655 uint8_t *whiteBalance = (uint8_t *)
3656 POINTER_OF_META(CAM_INTF_PARM_WHITE_BALANCE, metadata);
3657 uint8_t fwkWhiteBalanceMode =
3658 (uint8_t)lookupFwkName(WHITE_BALANCE_MODES_MAP,
3659 sizeof(WHITE_BALANCE_MODES_MAP)/
3660 sizeof(WHITE_BALANCE_MODES_MAP[0]), *whiteBalance);
3661 camMetadata.update(ANDROID_CONTROL_AWB_MODE,
3662 &fwkWhiteBalanceMode, 1);
3663 }
3664
3665 if (IS_META_AVAILABLE(CAM_INTF_META_AEC_MODE, metadata)) {
3666 aeMode = *((uint32_t*) POINTER_OF_META(CAM_INTF_META_AEC_MODE, metadata));
3667 }
3668 if (IS_META_AVAILABLE(CAM_INTF_PARM_LED_MODE, metadata)) {
3669 flashMode = (int32_t*)
3670 POINTER_OF_PARAM(CAM_INTF_PARM_LED_MODE, metadata);
3671 }
3672 if (IS_META_AVAILABLE(CAM_INTF_PARM_REDEYE_REDUCTION, metadata)) {
3673 redeye = (int32_t*)
3674 POINTER_OF_PARAM(CAM_INTF_PARM_REDEYE_REDUCTION, metadata);
3675 }
3676
3677 uint8_t fwk_aeMode;
3678 if (redeye != NULL && *redeye == 1) {
3679 fwk_aeMode = ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE;
3680 camMetadata.update(ANDROID_CONTROL_AE_MODE, &fwk_aeMode, 1);
3681 } else if (flashMode != NULL &&
3682 ((*flashMode == CAM_FLASH_MODE_AUTO)||
3683 (*flashMode == CAM_FLASH_MODE_ON))) {
3684 fwk_aeMode = (uint8_t)lookupFwkName(AE_FLASH_MODE_MAP,
3685 sizeof(AE_FLASH_MODE_MAP)/sizeof(AE_FLASH_MODE_MAP[0]),*flashMode);
3686 camMetadata.update(ANDROID_CONTROL_AE_MODE, &fwk_aeMode, 1);
3687 } else if (aeMode == CAM_AE_MODE_ON) {
3688 fwk_aeMode = ANDROID_CONTROL_AE_MODE_ON;
3689 camMetadata.update(ANDROID_CONTROL_AE_MODE, &fwk_aeMode, 1);
3690 } else if (aeMode == CAM_AE_MODE_OFF) {
3691 fwk_aeMode = ANDROID_CONTROL_AE_MODE_OFF;
3692 camMetadata.update(ANDROID_CONTROL_AE_MODE, &fwk_aeMode, 1);
3693 } else {
3694 ALOGE("%s: Not enough info to deduce ANDROID_CONTROL_AE_MODE redeye:%p, flashMode:%p, aeMode:%d!!!",__func__,
3695 redeye, flashMode, aeMode);
3696 }
3697
3698 if (IS_META_AVAILABLE(CAM_INTF_META_LENS_STATE, metadata)) {
3699 uint8_t *lensState = (uint8_t *)POINTER_OF_META(CAM_INTF_META_LENS_STATE, metadata);
3700 camMetadata.update(ANDROID_LENS_STATE , lensState, 1);
3701 }
3702
3703 resultMetadata = camMetadata.release();
3704 return resultMetadata;
3705 }
3706
3707 /*===========================================================================
3708 * FUNCTION : dumpMetadataToFile
3709 *
3710 * DESCRIPTION: Dumps tuning metadata to file system
3711 *
3712 * PARAMETERS :
3713 * @meta : tuning metadata
3714 * @dumpFrameCount : current dump frame count
3715 * @enabled : Enable mask
3716 *
3717 *==========================================================================*/
dumpMetadataToFile(tuning_params_t & meta,uint32_t & dumpFrameCount,int32_t enabled,const char * type,uint32_t frameNumber)3718 void QCamera3HardwareInterface::dumpMetadataToFile(tuning_params_t &meta,
3719 uint32_t &dumpFrameCount,
3720 int32_t enabled,
3721 const char *type,
3722 uint32_t frameNumber)
3723 {
3724 //Some sanity checks
3725 if (meta.tuning_sensor_data_size > TUNING_SENSOR_DATA_MAX) {
3726 ALOGE("%s : Tuning sensor data size bigger than expected %d: %d",
3727 __func__,
3728 meta.tuning_sensor_data_size,
3729 TUNING_SENSOR_DATA_MAX);
3730 return;
3731 }
3732
3733 if (meta.tuning_vfe_data_size > TUNING_VFE_DATA_MAX) {
3734 ALOGE("%s : Tuning VFE data size bigger than expected %d: %d",
3735 __func__,
3736 meta.tuning_vfe_data_size,
3737 TUNING_VFE_DATA_MAX);
3738 return;
3739 }
3740
3741 if (meta.tuning_cpp_data_size > TUNING_CPP_DATA_MAX) {
3742 ALOGE("%s : Tuning CPP data size bigger than expected %d: %d",
3743 __func__,
3744 meta.tuning_cpp_data_size,
3745 TUNING_CPP_DATA_MAX);
3746 return;
3747 }
3748
3749 if (meta.tuning_cac_data_size > TUNING_CAC_DATA_MAX) {
3750 ALOGE("%s : Tuning CAC data size bigger than expected %d: %d",
3751 __func__,
3752 meta.tuning_cac_data_size,
3753 TUNING_CAC_DATA_MAX);
3754 return;
3755 }
3756 //
3757
3758 if(enabled){
3759 char timeBuf[FILENAME_MAX];
3760 char buf[FILENAME_MAX];
3761 memset(buf, 0, sizeof(buf));
3762 memset(timeBuf, 0, sizeof(timeBuf));
3763 time_t current_time;
3764 struct tm * timeinfo;
3765 time (¤t_time);
3766 timeinfo = localtime (¤t_time);
3767 strftime (timeBuf, sizeof(timeBuf),"/data/%Y%m%d%H%M%S", timeinfo);
3768 String8 filePath(timeBuf);
3769 snprintf(buf,
3770 sizeof(buf),
3771 "%dm_%s_%d.bin",
3772 dumpFrameCount,
3773 type,
3774 frameNumber);
3775 filePath.append(buf);
3776 int file_fd = open(filePath.string(), O_RDWR | O_CREAT, 0777);
3777 if (file_fd >= 0) {
3778 int written_len = 0;
3779 meta.tuning_data_version = TUNING_DATA_VERSION;
3780 void *data = (void *)((uint8_t *)&meta.tuning_data_version);
3781 written_len += write(file_fd, data, sizeof(uint32_t));
3782 data = (void *)((uint8_t *)&meta.tuning_sensor_data_size);
3783 CDBG("tuning_sensor_data_size %d",(int)(*(int *)data));
3784 written_len += write(file_fd, data, sizeof(uint32_t));
3785 data = (void *)((uint8_t *)&meta.tuning_vfe_data_size);
3786 CDBG("tuning_vfe_data_size %d",(int)(*(int *)data));
3787 written_len += write(file_fd, data, sizeof(uint32_t));
3788 data = (void *)((uint8_t *)&meta.tuning_cpp_data_size);
3789 CDBG("tuning_cpp_data_size %d",(int)(*(int *)data));
3790 written_len += write(file_fd, data, sizeof(uint32_t));
3791 data = (void *)((uint8_t *)&meta.tuning_cac_data_size);
3792 CDBG("tuning_cac_data_size %d",(int)(*(int *)data));
3793 written_len += write(file_fd, data, sizeof(uint32_t));
3794 meta.tuning_mod3_data_size = 0;
3795 data = (void *)((uint8_t *)&meta.tuning_mod3_data_size);
3796 CDBG("tuning_mod3_data_size %d",(int)(*(int *)data));
3797 written_len += write(file_fd, data, sizeof(uint32_t));
3798 int total_size = meta.tuning_sensor_data_size;
3799 data = (void *)((uint8_t *)&meta.data);
3800 written_len += write(file_fd, data, total_size);
3801 total_size = meta.tuning_vfe_data_size;
3802 data = (void *)((uint8_t *)&meta.data[TUNING_VFE_DATA_OFFSET]);
3803 written_len += write(file_fd, data, total_size);
3804 total_size = meta.tuning_cpp_data_size;
3805 data = (void *)((uint8_t *)&meta.data[TUNING_CPP_DATA_OFFSET]);
3806 written_len += write(file_fd, data, total_size);
3807 total_size = meta.tuning_cac_data_size;
3808 data = (void *)((uint8_t *)&meta.data[TUNING_CAC_DATA_OFFSET]);
3809 written_len += write(file_fd, data, total_size);
3810 close(file_fd);
3811 }else {
3812 ALOGE("%s: fail to open file for metadata dumping", __func__);
3813 }
3814 }
3815 }
3816
3817 /*===========================================================================
3818 * FUNCTION : cleanAndSortStreamInfo
3819 *
3820 * DESCRIPTION: helper method to clean up invalid streams in stream_info,
3821 * and sort them such that raw stream is at the end of the list
3822 * This is a workaround for camera daemon constraint.
3823 *
3824 * PARAMETERS : None
3825 *
3826 *==========================================================================*/
cleanAndSortStreamInfo()3827 void QCamera3HardwareInterface::cleanAndSortStreamInfo()
3828 {
3829 List<stream_info_t *> newStreamInfo;
3830
3831 /*clean up invalid streams*/
3832 for (List<stream_info_t*>::iterator it=mStreamInfo.begin();
3833 it != mStreamInfo.end();) {
3834 if(((*it)->status) == INVALID){
3835 QCamera3Channel *channel = (QCamera3Channel*)(*it)->stream->priv;
3836 delete channel;
3837 free(*it);
3838 it = mStreamInfo.erase(it);
3839 } else {
3840 it++;
3841 }
3842 }
3843
3844 // Move preview/video/callback/snapshot streams into newList
3845 for (List<stream_info_t *>::iterator it = mStreamInfo.begin();
3846 it != mStreamInfo.end();) {
3847 if ((*it)->stream->format != HAL_PIXEL_FORMAT_RAW_OPAQUE &&
3848 (*it)->stream->format != HAL_PIXEL_FORMAT_RAW10 &&
3849 (*it)->stream->format != HAL_PIXEL_FORMAT_RAW16) {
3850 newStreamInfo.push_back(*it);
3851 it = mStreamInfo.erase(it);
3852 } else
3853 it++;
3854 }
3855 // Move raw streams into newList
3856 for (List<stream_info_t *>::iterator it = mStreamInfo.begin();
3857 it != mStreamInfo.end();) {
3858 newStreamInfo.push_back(*it);
3859 it = mStreamInfo.erase(it);
3860 }
3861
3862 mStreamInfo = newStreamInfo;
3863 }
3864
3865 /*===========================================================================
3866 * FUNCTION : extractJpegMetadata
3867 *
3868 * DESCRIPTION: helper method to extract Jpeg metadata from capture request.
3869 * JPEG metadata is cached in HAL, and return as part of capture
3870 * result when metadata is returned from camera daemon.
3871 *
3872 * PARAMETERS : @jpegMetadata: jpeg metadata to be extracted
3873 * @request: capture request
3874 *
3875 *==========================================================================*/
extractJpegMetadata(CameraMetadata & jpegMetadata,const camera3_capture_request_t * request)3876 void QCamera3HardwareInterface::extractJpegMetadata(
3877 CameraMetadata& jpegMetadata,
3878 const camera3_capture_request_t *request)
3879 {
3880 CameraMetadata frame_settings;
3881 frame_settings = request->settings;
3882
3883 if (frame_settings.exists(ANDROID_JPEG_GPS_COORDINATES))
3884 jpegMetadata.update(ANDROID_JPEG_GPS_COORDINATES,
3885 frame_settings.find(ANDROID_JPEG_GPS_COORDINATES).data.d,
3886 frame_settings.find(ANDROID_JPEG_GPS_COORDINATES).count);
3887
3888 if (frame_settings.exists(ANDROID_JPEG_GPS_PROCESSING_METHOD))
3889 jpegMetadata.update(ANDROID_JPEG_GPS_PROCESSING_METHOD,
3890 frame_settings.find(ANDROID_JPEG_GPS_PROCESSING_METHOD).data.u8,
3891 frame_settings.find(ANDROID_JPEG_GPS_PROCESSING_METHOD).count);
3892
3893 if (frame_settings.exists(ANDROID_JPEG_GPS_TIMESTAMP))
3894 jpegMetadata.update(ANDROID_JPEG_GPS_TIMESTAMP,
3895 frame_settings.find(ANDROID_JPEG_GPS_TIMESTAMP).data.i64,
3896 frame_settings.find(ANDROID_JPEG_GPS_TIMESTAMP).count);
3897
3898 if (frame_settings.exists(ANDROID_JPEG_ORIENTATION))
3899 jpegMetadata.update(ANDROID_JPEG_ORIENTATION,
3900 frame_settings.find(ANDROID_JPEG_ORIENTATION).data.i32,
3901 frame_settings.find(ANDROID_JPEG_ORIENTATION).count);
3902
3903 if (frame_settings.exists(ANDROID_JPEG_QUALITY))
3904 jpegMetadata.update(ANDROID_JPEG_QUALITY,
3905 frame_settings.find(ANDROID_JPEG_QUALITY).data.u8,
3906 frame_settings.find(ANDROID_JPEG_QUALITY).count);
3907
3908 if (frame_settings.exists(ANDROID_JPEG_THUMBNAIL_QUALITY))
3909 jpegMetadata.update(ANDROID_JPEG_THUMBNAIL_QUALITY,
3910 frame_settings.find(ANDROID_JPEG_THUMBNAIL_QUALITY).data.u8,
3911 frame_settings.find(ANDROID_JPEG_THUMBNAIL_QUALITY).count);
3912
3913 if (frame_settings.exists(ANDROID_JPEG_THUMBNAIL_SIZE)) {
3914 int32_t thumbnail_size[2];
3915 thumbnail_size[0] = frame_settings.find(ANDROID_JPEG_THUMBNAIL_SIZE).data.i32[0];
3916 thumbnail_size[1] = frame_settings.find(ANDROID_JPEG_THUMBNAIL_SIZE).data.i32[1];
3917 if (frame_settings.exists(ANDROID_JPEG_ORIENTATION)) {
3918 int32_t orientation =
3919 frame_settings.find(ANDROID_JPEG_ORIENTATION).data.i32[0];
3920 if ((orientation == 90) || (orientation == 270)) {
3921 //swap thumbnail dimensions for rotations 90 and 270 in jpeg metadata.
3922 int32_t temp;
3923 temp = thumbnail_size[0];
3924 thumbnail_size[0] = thumbnail_size[1];
3925 thumbnail_size[1] = temp;
3926 }
3927 }
3928 jpegMetadata.update(ANDROID_JPEG_THUMBNAIL_SIZE,
3929 thumbnail_size,
3930 frame_settings.find(ANDROID_JPEG_THUMBNAIL_SIZE).count);
3931 }
3932 }
3933
3934 /*===========================================================================
3935 * FUNCTION : convertToRegions
3936 *
3937 * DESCRIPTION: helper method to convert from cam_rect_t into int32_t array
3938 *
3939 * PARAMETERS :
3940 * @rect : cam_rect_t struct to convert
3941 * @region : int32_t destination array
3942 * @weight : if we are converting from cam_area_t, weight is valid
3943 * else weight = -1
3944 *
3945 *==========================================================================*/
convertToRegions(cam_rect_t rect,int32_t * region,int weight)3946 void QCamera3HardwareInterface::convertToRegions(cam_rect_t rect, int32_t* region, int weight){
3947 region[0] = rect.left;
3948 region[1] = rect.top;
3949 region[2] = rect.left + rect.width;
3950 region[3] = rect.top + rect.height;
3951 if (weight > -1) {
3952 region[4] = weight;
3953 }
3954 }
3955
3956 /*===========================================================================
3957 * FUNCTION : convertFromRegions
3958 *
3959 * DESCRIPTION: helper method to convert from array to cam_rect_t
3960 *
3961 * PARAMETERS :
3962 * @rect : cam_rect_t struct to convert
3963 * @region : int32_t destination array
3964 * @weight : if we are converting from cam_area_t, weight is valid
3965 * else weight = -1
3966 *
3967 *==========================================================================*/
convertFromRegions(cam_area_t * roi,const camera_metadata_t * settings,uint32_t tag)3968 void QCamera3HardwareInterface::convertFromRegions(cam_area_t* roi,
3969 const camera_metadata_t *settings,
3970 uint32_t tag){
3971 CameraMetadata frame_settings;
3972 frame_settings = settings;
3973 int32_t x_min = frame_settings.find(tag).data.i32[0];
3974 int32_t y_min = frame_settings.find(tag).data.i32[1];
3975 int32_t x_max = frame_settings.find(tag).data.i32[2];
3976 int32_t y_max = frame_settings.find(tag).data.i32[3];
3977 roi->weight = frame_settings.find(tag).data.i32[4];
3978 roi->rect.left = x_min;
3979 roi->rect.top = y_min;
3980 roi->rect.width = x_max - x_min;
3981 roi->rect.height = y_max - y_min;
3982 }
3983
3984 /*===========================================================================
3985 * FUNCTION : resetIfNeededROI
3986 *
3987 * DESCRIPTION: helper method to reset the roi if it is greater than scaler
3988 * crop region
3989 *
3990 * PARAMETERS :
3991 * @roi : cam_area_t struct to resize
3992 * @scalerCropRegion : cam_crop_region_t region to compare against
3993 *
3994 *
3995 *==========================================================================*/
resetIfNeededROI(cam_area_t * roi,const cam_crop_region_t * scalerCropRegion)3996 bool QCamera3HardwareInterface::resetIfNeededROI(cam_area_t* roi,
3997 const cam_crop_region_t* scalerCropRegion)
3998 {
3999 int32_t roi_x_max = roi->rect.width + roi->rect.left;
4000 int32_t roi_y_max = roi->rect.height + roi->rect.top;
4001 int32_t crop_x_max = scalerCropRegion->width + scalerCropRegion->left;
4002 int32_t crop_y_max = scalerCropRegion->height + scalerCropRegion->top;
4003
4004 /* According to spec weight = 0 is used to indicate roi needs to be disabled
4005 * without having this check the calculations below to validate if the roi
4006 * is inside scalar crop region will fail resulting in the roi not being
4007 * reset causing algorithm to continue to use stale roi window
4008 */
4009 if (roi->weight == 0) {
4010 return true;
4011 }
4012
4013 if ((roi_x_max < scalerCropRegion->left) ||
4014 // right edge of roi window is left of scalar crop's left edge
4015 (roi_y_max < scalerCropRegion->top) ||
4016 // bottom edge of roi window is above scalar crop's top edge
4017 (roi->rect.left > crop_x_max) ||
4018 // left edge of roi window is beyond(right) of scalar crop's right edge
4019 (roi->rect.top > crop_y_max)){
4020 // top edge of roi windo is above scalar crop's top edge
4021 return false;
4022 }
4023 if (roi->rect.left < scalerCropRegion->left) {
4024 roi->rect.left = scalerCropRegion->left;
4025 }
4026 if (roi->rect.top < scalerCropRegion->top) {
4027 roi->rect.top = scalerCropRegion->top;
4028 }
4029 if (roi_x_max > crop_x_max) {
4030 roi_x_max = crop_x_max;
4031 }
4032 if (roi_y_max > crop_y_max) {
4033 roi_y_max = crop_y_max;
4034 }
4035 roi->rect.width = roi_x_max - roi->rect.left;
4036 roi->rect.height = roi_y_max - roi->rect.top;
4037 return true;
4038 }
4039
4040 /*===========================================================================
4041 * FUNCTION : convertLandmarks
4042 *
4043 * DESCRIPTION: helper method to extract the landmarks from face detection info
4044 *
4045 * PARAMETERS :
4046 * @face : cam_rect_t struct to convert
4047 * @landmarks : int32_t destination array
4048 *
4049 *
4050 *==========================================================================*/
convertLandmarks(cam_face_detection_info_t face,int32_t * landmarks)4051 void QCamera3HardwareInterface::convertLandmarks(cam_face_detection_info_t face, int32_t* landmarks)
4052 {
4053 landmarks[0] = face.left_eye_center.x;
4054 landmarks[1] = face.left_eye_center.y;
4055 landmarks[2] = face.right_eye_center.x;
4056 landmarks[3] = face.right_eye_center.y;
4057 landmarks[4] = face.mouth_center.x;
4058 landmarks[5] = face.mouth_center.y;
4059 }
4060
4061 #define DATA_PTR(MEM_OBJ,INDEX) MEM_OBJ->getPtr( INDEX )
4062 /*===========================================================================
4063 * FUNCTION : initCapabilities
4064 *
4065 * DESCRIPTION: initialize camera capabilities in static data struct
4066 *
4067 * PARAMETERS :
4068 * @cameraId : camera Id
4069 *
4070 * RETURN : int32_t type of status
4071 * NO_ERROR -- success
4072 * none-zero failure code
4073 *==========================================================================*/
initCapabilities(int cameraId)4074 int QCamera3HardwareInterface::initCapabilities(int cameraId)
4075 {
4076 int rc = 0;
4077 mm_camera_vtbl_t *cameraHandle = NULL;
4078 QCamera3HeapMemory *capabilityHeap = NULL;
4079
4080 cameraHandle = camera_open(cameraId);
4081 if (!cameraHandle) {
4082 ALOGE("%s: camera_open failed", __func__);
4083 rc = -1;
4084 goto open_failed;
4085 }
4086
4087 capabilityHeap = new QCamera3HeapMemory();
4088 if (capabilityHeap == NULL) {
4089 ALOGE("%s: creation of capabilityHeap failed", __func__);
4090 goto heap_creation_failed;
4091 }
4092 /* Allocate memory for capability buffer */
4093 rc = capabilityHeap->allocate(1, sizeof(cam_capability_t), false);
4094 if(rc != OK) {
4095 ALOGE("%s: No memory for cappability", __func__);
4096 goto allocate_failed;
4097 }
4098
4099 /* Map memory for capability buffer */
4100 memset(DATA_PTR(capabilityHeap,0), 0, sizeof(cam_capability_t));
4101 rc = cameraHandle->ops->map_buf(cameraHandle->camera_handle,
4102 CAM_MAPPING_BUF_TYPE_CAPABILITY,
4103 capabilityHeap->getFd(0),
4104 sizeof(cam_capability_t));
4105 if(rc < 0) {
4106 ALOGE("%s: failed to map capability buffer", __func__);
4107 goto map_failed;
4108 }
4109
4110 /* Query Capability */
4111 rc = cameraHandle->ops->query_capability(cameraHandle->camera_handle);
4112 if(rc < 0) {
4113 ALOGE("%s: failed to query capability",__func__);
4114 goto query_failed;
4115 }
4116 gCamCapability[cameraId] = (cam_capability_t *)malloc(sizeof(cam_capability_t));
4117 if (!gCamCapability[cameraId]) {
4118 ALOGE("%s: out of memory", __func__);
4119 goto query_failed;
4120 }
4121 memcpy(gCamCapability[cameraId], DATA_PTR(capabilityHeap,0),
4122 sizeof(cam_capability_t));
4123 rc = 0;
4124
4125 query_failed:
4126 cameraHandle->ops->unmap_buf(cameraHandle->camera_handle,
4127 CAM_MAPPING_BUF_TYPE_CAPABILITY);
4128 map_failed:
4129 capabilityHeap->deallocate();
4130 allocate_failed:
4131 delete capabilityHeap;
4132 heap_creation_failed:
4133 cameraHandle->ops->close_camera(cameraHandle->camera_handle);
4134 cameraHandle = NULL;
4135 open_failed:
4136 return rc;
4137 }
4138
4139 /*===========================================================================
4140 * FUNCTION : initParameters
4141 *
4142 * DESCRIPTION: initialize camera parameters
4143 *
4144 * PARAMETERS :
4145 *
4146 * RETURN : int32_t type of status
4147 * NO_ERROR -- success
4148 * none-zero failure code
4149 *==========================================================================*/
initParameters()4150 int QCamera3HardwareInterface::initParameters()
4151 {
4152 int rc = 0;
4153
4154 //Allocate Set Param Buffer
4155 mParamHeap = new QCamera3HeapMemory();
4156 rc = mParamHeap->allocate(1, sizeof(metadata_buffer_t), false);
4157 if(rc != OK) {
4158 rc = NO_MEMORY;
4159 ALOGE("Failed to allocate SETPARM Heap memory");
4160 delete mParamHeap;
4161 mParamHeap = NULL;
4162 return rc;
4163 }
4164
4165 //Map memory for parameters buffer
4166 rc = mCameraHandle->ops->map_buf(mCameraHandle->camera_handle,
4167 CAM_MAPPING_BUF_TYPE_PARM_BUF,
4168 mParamHeap->getFd(0),
4169 sizeof(metadata_buffer_t));
4170 if(rc < 0) {
4171 ALOGE("%s:failed to map SETPARM buffer",__func__);
4172 rc = FAILED_TRANSACTION;
4173 mParamHeap->deallocate();
4174 delete mParamHeap;
4175 mParamHeap = NULL;
4176 return rc;
4177 }
4178
4179 mParameters = (metadata_buffer_t*) DATA_PTR(mParamHeap,0);
4180 mPrevParameters = (metadata_buffer_t *)malloc(sizeof(metadata_buffer_t));
4181 return rc;
4182 }
4183
4184 /*===========================================================================
4185 * FUNCTION : deinitParameters
4186 *
4187 * DESCRIPTION: de-initialize camera parameters
4188 *
4189 * PARAMETERS :
4190 *
4191 * RETURN : NONE
4192 *==========================================================================*/
deinitParameters()4193 void QCamera3HardwareInterface::deinitParameters()
4194 {
4195 mCameraHandle->ops->unmap_buf(mCameraHandle->camera_handle,
4196 CAM_MAPPING_BUF_TYPE_PARM_BUF);
4197
4198 mParamHeap->deallocate();
4199 delete mParamHeap;
4200 mParamHeap = NULL;
4201
4202 mParameters = NULL;
4203
4204 free(mPrevParameters);
4205 mPrevParameters = NULL;
4206 }
4207
4208 /*===========================================================================
4209 * FUNCTION : calcMaxJpegSize
4210 *
4211 * DESCRIPTION: Calculates maximum jpeg size supported by the cameraId
4212 *
4213 * PARAMETERS :
4214 *
4215 * RETURN : max_jpeg_size
4216 *==========================================================================*/
calcMaxJpegSize(uint8_t camera_id)4217 int QCamera3HardwareInterface::calcMaxJpegSize(uint8_t camera_id)
4218 {
4219 int32_t max_jpeg_size = 0;
4220 int temp_width, temp_height;
4221 for (int i = 0; i < gCamCapability[camera_id]->picture_sizes_tbl_cnt; i++) {
4222 temp_width = gCamCapability[camera_id]->picture_sizes_tbl[i].width;
4223 temp_height = gCamCapability[camera_id]->picture_sizes_tbl[i].height;
4224 if (temp_width * temp_height > max_jpeg_size ) {
4225 max_jpeg_size = temp_width * temp_height;
4226 }
4227 }
4228 max_jpeg_size = max_jpeg_size * 3/2 + sizeof(camera3_jpeg_blob_t);
4229 return max_jpeg_size;
4230 }
4231
4232 /*===========================================================================
4233 * FUNCTION : getMaxRawSize
4234 *
4235 * DESCRIPTION: Fetches maximum raw size supported by the cameraId
4236 *
4237 * PARAMETERS :
4238 *
4239 * RETURN : Largest supported Raw Dimension
4240 *==========================================================================*/
getMaxRawSize(uint8_t camera_id)4241 cam_dimension_t QCamera3HardwareInterface::getMaxRawSize(uint8_t camera_id)
4242 {
4243 int max_width = 0;
4244 cam_dimension_t maxRawSize;
4245
4246 memset(&maxRawSize, 0, sizeof(cam_dimension_t));
4247 for (int i = 0; i < gCamCapability[camera_id]->supported_raw_dim_cnt; i++) {
4248 if (max_width < gCamCapability[camera_id]->raw_dim[i].width) {
4249 max_width = gCamCapability[camera_id]->raw_dim[i].width;
4250 maxRawSize = gCamCapability[camera_id]->raw_dim[i];
4251 }
4252 }
4253 return maxRawSize;
4254 }
4255
4256
4257 /*===========================================================================
4258 * FUNCTION : calcMaxJpegDim
4259 *
4260 * DESCRIPTION: Calculates maximum jpeg dimension supported by the cameraId
4261 *
4262 * PARAMETERS :
4263 *
4264 * RETURN : max_jpeg_dim
4265 *==========================================================================*/
calcMaxJpegDim()4266 cam_dimension_t QCamera3HardwareInterface::calcMaxJpegDim()
4267 {
4268 cam_dimension_t max_jpeg_dim;
4269 cam_dimension_t curr_jpeg_dim;
4270 max_jpeg_dim.width = 0;
4271 max_jpeg_dim.height = 0;
4272 curr_jpeg_dim.width = 0;
4273 curr_jpeg_dim.height = 0;
4274 for (int i = 0; i < gCamCapability[mCameraId]->picture_sizes_tbl_cnt; i++) {
4275 curr_jpeg_dim.width = gCamCapability[mCameraId]->picture_sizes_tbl[i].width;
4276 curr_jpeg_dim.height = gCamCapability[mCameraId]->picture_sizes_tbl[i].height;
4277 if (curr_jpeg_dim.width * curr_jpeg_dim.height >
4278 max_jpeg_dim.width * max_jpeg_dim.height ) {
4279 max_jpeg_dim.width = curr_jpeg_dim.width;
4280 max_jpeg_dim.height = curr_jpeg_dim.height;
4281 }
4282 }
4283 return max_jpeg_dim;
4284 }
4285
4286
4287 /*===========================================================================
4288 * FUNCTION : initStaticMetadata
4289 *
4290 * DESCRIPTION: initialize the static metadata
4291 *
4292 * PARAMETERS :
4293 * @cameraId : camera Id
4294 *
4295 * RETURN : int32_t type of status
4296 * 0 -- success
4297 * non-zero failure code
4298 *==========================================================================*/
initStaticMetadata(int cameraId)4299 int QCamera3HardwareInterface::initStaticMetadata(int cameraId)
4300 {
4301 int rc = 0;
4302 CameraMetadata staticInfo;
4303
4304 bool facingBack = gCamCapability[cameraId]->position == CAM_POSITION_BACK;
4305 if (!facingBack)
4306 gCamCapability[cameraId]->supported_raw_dim_cnt = 0;
4307
4308 /* android.info: hardware level */
4309 uint8_t supportedHardwareLevel = (facingBack)? ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_FULL:
4310 ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED;
4311 staticInfo.update(ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL,
4312 &supportedHardwareLevel, 1);
4313 /*HAL 3 only*/
4314 staticInfo.update(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE,
4315 &gCamCapability[cameraId]->min_focus_distance, 1);
4316
4317 uint8_t aeLockAvailable = (gCamCapability[cameraId]->sensor_type.sens_type == CAM_SENSOR_RAW) ?
4318 ANDROID_CONTROL_AE_LOCK_AVAILABLE_TRUE : ANDROID_CONTROL_AE_LOCK_AVAILABLE_FALSE;
4319
4320 staticInfo.update(ANDROID_CONTROL_AE_LOCK_AVAILABLE,
4321 &aeLockAvailable, 1);
4322
4323 uint8_t awbLockAvailable = (gCamCapability[cameraId]->sensor_type.sens_type == CAM_SENSOR_RAW) ?
4324 ANDROID_CONTROL_AWB_LOCK_AVAILABLE_TRUE : ANDROID_CONTROL_AWB_LOCK_AVAILABLE_FALSE;
4325
4326 staticInfo.update(ANDROID_CONTROL_AWB_LOCK_AVAILABLE,
4327 &awbLockAvailable, 1);
4328
4329 staticInfo.update(ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE,
4330 &gCamCapability[cameraId]->hyper_focal_distance, 1);
4331
4332 /*should be using focal lengths but sensor doesn't provide that info now*/
4333 staticInfo.update(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS,
4334 &gCamCapability[cameraId]->focal_length,
4335 1);
4336
4337 staticInfo.update(ANDROID_LENS_INFO_AVAILABLE_APERTURES,
4338 gCamCapability[cameraId]->apertures,
4339 gCamCapability[cameraId]->apertures_count);
4340
4341 staticInfo.update(ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES,
4342 gCamCapability[cameraId]->filter_densities,
4343 gCamCapability[cameraId]->filter_densities_count);
4344
4345
4346 staticInfo.update(ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION,
4347 (uint8_t*)gCamCapability[cameraId]->optical_stab_modes,
4348 gCamCapability[cameraId]->optical_stab_modes_count);
4349
4350 int32_t lens_shading_map_size[] = {gCamCapability[cameraId]->lens_shading_map_size.width,
4351 gCamCapability[cameraId]->lens_shading_map_size.height};
4352 staticInfo.update(ANDROID_LENS_INFO_SHADING_MAP_SIZE,
4353 lens_shading_map_size,
4354 sizeof(lens_shading_map_size)/sizeof(int32_t));
4355
4356 staticInfo.update(ANDROID_SENSOR_INFO_PHYSICAL_SIZE,
4357 gCamCapability[cameraId]->sensor_physical_size, 2);
4358
4359 staticInfo.update(ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE,
4360 gCamCapability[cameraId]->exposure_time_range, 2);
4361
4362 staticInfo.update(ANDROID_SENSOR_INFO_MAX_FRAME_DURATION,
4363 &gCamCapability[cameraId]->max_frame_duration, 1);
4364
4365 camera_metadata_rational baseGainFactor = {
4366 gCamCapability[cameraId]->base_gain_factor.numerator,
4367 gCamCapability[cameraId]->base_gain_factor.denominator};
4368 staticInfo.update(ANDROID_SENSOR_BASE_GAIN_FACTOR,
4369 &baseGainFactor, 1);
4370
4371 staticInfo.update(ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT,
4372 (uint8_t*)&gCamCapability[cameraId]->color_arrangement, 1);
4373
4374 int32_t pixel_array_size[] = {gCamCapability[cameraId]->pixel_array_size.width,
4375 gCamCapability[cameraId]->pixel_array_size.height};
4376 staticInfo.update(ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE,
4377 pixel_array_size, 2);
4378
4379 int32_t active_array_size[] = {gCamCapability[cameraId]->active_array_size.left,
4380 gCamCapability[cameraId]->active_array_size.top,
4381 gCamCapability[cameraId]->active_array_size.width,
4382 gCamCapability[cameraId]->active_array_size.height};
4383 staticInfo.update(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE,
4384 active_array_size, 4);
4385
4386 staticInfo.update(ANDROID_SENSOR_INFO_WHITE_LEVEL,
4387 &gCamCapability[cameraId]->white_level, 1);
4388
4389 staticInfo.update(ANDROID_SENSOR_BLACK_LEVEL_PATTERN,
4390 gCamCapability[cameraId]->black_level_pattern, 4);
4391
4392 staticInfo.update(ANDROID_FLASH_INFO_CHARGE_DURATION,
4393 &gCamCapability[cameraId]->flash_charge_duration, 1);
4394
4395 staticInfo.update(ANDROID_TONEMAP_MAX_CURVE_POINTS,
4396 &gCamCapability[cameraId]->max_tone_map_curve_points, 1);
4397
4398 int32_t maxFaces = gCamCapability[cameraId]->max_num_roi;
4399 staticInfo.update(ANDROID_STATISTICS_INFO_MAX_FACE_COUNT,
4400 (int32_t*)&maxFaces, 1);
4401
4402 uint8_t timestampSource = ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE_UNKNOWN;
4403 if (0 && gCamCapability[cameraId]->isTimestampCalibrated) {
4404 timestampSource = ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE_REALTIME;
4405 }
4406 staticInfo.update(ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE,
4407 ×tampSource, 1);
4408
4409 staticInfo.update(ANDROID_STATISTICS_INFO_HISTOGRAM_BUCKET_COUNT,
4410 &gCamCapability[cameraId]->histogram_size, 1);
4411
4412 staticInfo.update(ANDROID_STATISTICS_INFO_MAX_HISTOGRAM_COUNT,
4413 &gCamCapability[cameraId]->max_histogram_count, 1);
4414
4415 int32_t sharpness_map_size[] = {gCamCapability[cameraId]->sharpness_map_size.width,
4416 gCamCapability[cameraId]->sharpness_map_size.height};
4417
4418 staticInfo.update(ANDROID_STATISTICS_INFO_SHARPNESS_MAP_SIZE,
4419 sharpness_map_size, sizeof(sharpness_map_size)/sizeof(int32_t));
4420
4421 staticInfo.update(ANDROID_STATISTICS_INFO_MAX_SHARPNESS_MAP_VALUE,
4422 &gCamCapability[cameraId]->max_sharpness_map_value, 1);
4423
4424 int32_t scalar_formats[] = {
4425 ANDROID_SCALER_AVAILABLE_FORMATS_RAW_OPAQUE,
4426 ANDROID_SCALER_AVAILABLE_FORMATS_RAW16,
4427 ANDROID_SCALER_AVAILABLE_FORMATS_YCbCr_420_888,
4428 ANDROID_SCALER_AVAILABLE_FORMATS_BLOB,
4429 HAL_PIXEL_FORMAT_RAW10,
4430 HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED};
4431 int scalar_formats_count = sizeof(scalar_formats)/sizeof(int32_t);
4432 staticInfo.update(ANDROID_SCALER_AVAILABLE_FORMATS,
4433 scalar_formats,
4434 scalar_formats_count);
4435
4436 int32_t available_processed_sizes[MAX_SIZES_CNT * 2];
4437 makeTable(gCamCapability[cameraId]->picture_sizes_tbl,
4438 gCamCapability[cameraId]->picture_sizes_tbl_cnt,
4439 available_processed_sizes);
4440 staticInfo.update(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES,
4441 available_processed_sizes,
4442 (gCamCapability[cameraId]->picture_sizes_tbl_cnt) * 2);
4443
4444 int32_t available_raw_sizes[MAX_SIZES_CNT * 2];
4445 makeTable(gCamCapability[cameraId]->raw_dim,
4446 gCamCapability[cameraId]->supported_raw_dim_cnt,
4447 available_raw_sizes);
4448 staticInfo.update(ANDROID_SCALER_AVAILABLE_RAW_SIZES,
4449 available_raw_sizes,
4450 gCamCapability[cameraId]->supported_raw_dim_cnt * 2);
4451
4452 int32_t available_fps_ranges[MAX_SIZES_CNT * 2];
4453 makeFPSTable(gCamCapability[cameraId]->fps_ranges_tbl,
4454 gCamCapability[cameraId]->fps_ranges_tbl_cnt,
4455 available_fps_ranges);
4456 staticInfo.update(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
4457 available_fps_ranges, (gCamCapability[cameraId]->fps_ranges_tbl_cnt*2) );
4458
4459 camera_metadata_rational exposureCompensationStep = {
4460 gCamCapability[cameraId]->exp_compensation_step.numerator,
4461 gCamCapability[cameraId]->exp_compensation_step.denominator};
4462 staticInfo.update(ANDROID_CONTROL_AE_COMPENSATION_STEP,
4463 &exposureCompensationStep, 1);
4464
4465 uint8_t availableVstabModes[] = {ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF};
4466 staticInfo.update(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES,
4467 availableVstabModes, sizeof(availableVstabModes));
4468
4469 /*HAL 1 and HAL 3 common*/
4470 float maxZoom = 4;
4471 staticInfo.update(ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM,
4472 &maxZoom, 1);
4473
4474 uint8_t croppingType = ANDROID_SCALER_CROPPING_TYPE_FREEFORM;
4475 staticInfo.update(ANDROID_SCALER_CROPPING_TYPE, &croppingType, 1);
4476
4477 int32_t max3aRegions[3] = {/*AE*/1,/*AWB*/ 0,/*AF*/ 1};
4478 if (gCamCapability[cameraId]->supported_focus_modes_cnt == 1)
4479 max3aRegions[2] = 0; /* AF not supported */
4480 staticInfo.update(ANDROID_CONTROL_MAX_REGIONS,
4481 max3aRegions, 3);
4482
4483 uint8_t availableFaceDetectModes[] = {
4484 ANDROID_STATISTICS_FACE_DETECT_MODE_OFF,
4485 ANDROID_STATISTICS_FACE_DETECT_MODE_FULL };
4486 staticInfo.update(ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES,
4487 availableFaceDetectModes,
4488 sizeof(availableFaceDetectModes));
4489
4490 int32_t exposureCompensationRange[] = {gCamCapability[cameraId]->exposure_compensation_min,
4491 gCamCapability[cameraId]->exposure_compensation_max};
4492 staticInfo.update(ANDROID_CONTROL_AE_COMPENSATION_RANGE,
4493 exposureCompensationRange,
4494 sizeof(exposureCompensationRange)/sizeof(int32_t));
4495
4496 uint8_t lensFacing = (facingBack) ?
4497 ANDROID_LENS_FACING_BACK : ANDROID_LENS_FACING_FRONT;
4498 staticInfo.update(ANDROID_LENS_FACING, &lensFacing, 1);
4499
4500 staticInfo.update(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES,
4501 available_thumbnail_sizes,
4502 sizeof(available_thumbnail_sizes)/sizeof(int32_t));
4503
4504 /*all sizes will be clubbed into this tag*/
4505 int32_t available_jpeg_sizes[MAX_SIZES_CNT * 2];
4506 uint8_t jpeg_sizes_cnt = filterJpegSizes(available_jpeg_sizes, available_processed_sizes,
4507 (gCamCapability[cameraId]->picture_sizes_tbl_cnt) * 2,
4508 MAX_SIZES_CNT * 2,
4509 gCamCapability[cameraId]->active_array_size,
4510 gCamCapability[cameraId]->max_downscale_factor);
4511 /*android.scaler.availableStreamConfigurations*/
4512 int32_t max_stream_configs_size =
4513 gCamCapability[cameraId]->picture_sizes_tbl_cnt *
4514 sizeof(scalar_formats)/sizeof(int32_t) * 4;
4515 int32_t available_stream_configs[max_stream_configs_size];
4516 int idx = 0;
4517
4518 /* Add input/output stream configurations for each scalar formats*/
4519 for (int j = 0; j < scalar_formats_count; j++) {
4520 switch (scalar_formats[j]) {
4521 case ANDROID_SCALER_AVAILABLE_FORMATS_RAW16:
4522 case ANDROID_SCALER_AVAILABLE_FORMATS_RAW_OPAQUE:
4523 case HAL_PIXEL_FORMAT_RAW10:
4524 for (int i = 0;
4525 i < gCamCapability[cameraId]->supported_raw_dim_cnt; i++) {
4526 available_stream_configs[idx] = scalar_formats[j];
4527 available_stream_configs[idx+1] =
4528 gCamCapability[cameraId]->raw_dim[i].width;
4529 available_stream_configs[idx+2] =
4530 gCamCapability[cameraId]->raw_dim[i].height;
4531 available_stream_configs[idx+3] =
4532 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT;
4533 idx+=4;
4534 }
4535 break;
4536 case HAL_PIXEL_FORMAT_BLOB:
4537 for (int i = 0; i < jpeg_sizes_cnt/2; i++) {
4538 available_stream_configs[idx] = scalar_formats[j];
4539 available_stream_configs[idx+1] = available_jpeg_sizes[i*2];
4540 available_stream_configs[idx+2] = available_jpeg_sizes[i*2+1];
4541 available_stream_configs[idx+3] = ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT;
4542 idx+=4;
4543 }
4544 break;
4545
4546 case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED:
4547 case HAL_PIXEL_FORMAT_YCbCr_420_888:
4548 default:
4549 cam_dimension_t largest_picture_size;
4550 memset(&largest_picture_size, 0, sizeof(cam_dimension_t));
4551 for (int i = 0;
4552 i < gCamCapability[cameraId]->picture_sizes_tbl_cnt; i++) {
4553 available_stream_configs[idx] = scalar_formats[j];
4554 available_stream_configs[idx+1] =
4555 gCamCapability[cameraId]->picture_sizes_tbl[i].width;
4556 available_stream_configs[idx+2] =
4557 gCamCapability[cameraId]->picture_sizes_tbl[i].height;
4558 available_stream_configs[idx+3] =
4559 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT;
4560 idx+=4;
4561
4562 /* Book keep largest */
4563 if (gCamCapability[cameraId]->picture_sizes_tbl[i].width
4564 >= largest_picture_size.width &&
4565 gCamCapability[cameraId]->picture_sizes_tbl[i].height
4566 >= largest_picture_size.height)
4567 largest_picture_size = gCamCapability[cameraId]->picture_sizes_tbl[i];
4568 }
4569
4570 break;
4571 }
4572 }
4573
4574 staticInfo.update(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS,
4575 available_stream_configs, idx);
4576 static const uint8_t hotpixelMode = ANDROID_HOT_PIXEL_MODE_FAST;
4577 staticInfo.update(ANDROID_HOT_PIXEL_MODE, &hotpixelMode, 1);
4578
4579 static const uint8_t hotPixelMapMode = ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE_OFF;
4580 staticInfo.update(ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE, &hotPixelMapMode, 1);
4581
4582 /* android.scaler.availableMinFrameDurations */
4583 int64_t available_min_durations[max_stream_configs_size];
4584 idx = 0;
4585 for (int j = 0; j < scalar_formats_count; j++) {
4586 switch (scalar_formats[j]) {
4587 case ANDROID_SCALER_AVAILABLE_FORMATS_RAW16:
4588 case ANDROID_SCALER_AVAILABLE_FORMATS_RAW_OPAQUE:
4589 case HAL_PIXEL_FORMAT_RAW10:
4590 for (int i = 0;
4591 i < gCamCapability[cameraId]->supported_raw_dim_cnt; i++) {
4592 available_min_durations[idx] = scalar_formats[j];
4593 available_min_durations[idx+1] =
4594 gCamCapability[cameraId]->raw_dim[i].width;
4595 available_min_durations[idx+2] =
4596 gCamCapability[cameraId]->raw_dim[i].height;
4597 available_min_durations[idx+3] =
4598 gCamCapability[cameraId]->raw_min_duration[i];
4599 idx+=4;
4600 }
4601 break;
4602 default:
4603 for (int i = 0;
4604 i < gCamCapability[cameraId]->picture_sizes_tbl_cnt; i++) {
4605 available_min_durations[idx] = scalar_formats[j];
4606 available_min_durations[idx+1] =
4607 gCamCapability[cameraId]->picture_sizes_tbl[i].width;
4608 available_min_durations[idx+2] =
4609 gCamCapability[cameraId]->picture_sizes_tbl[i].height;
4610 available_min_durations[idx+3] =
4611 gCamCapability[cameraId]->picture_min_duration[i];
4612 idx+=4;
4613 }
4614 break;
4615 }
4616 }
4617 staticInfo.update(ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS,
4618 &available_min_durations[0], idx);
4619
4620 int32_t max_jpeg_size = calcMaxJpegSize(cameraId);
4621 staticInfo.update(ANDROID_JPEG_MAX_SIZE,
4622 &max_jpeg_size, 1);
4623
4624 uint8_t avail_effects[CAM_EFFECT_MODE_MAX];
4625 size_t size = 0;
4626 for (int i = 0; i < gCamCapability[cameraId]->supported_effects_cnt; i++) {
4627 int32_t val = lookupFwkName(EFFECT_MODES_MAP,
4628 sizeof(EFFECT_MODES_MAP)/sizeof(EFFECT_MODES_MAP[0]),
4629 gCamCapability[cameraId]->supported_effects[i]);
4630 if (val != NAME_NOT_FOUND) {
4631 avail_effects[size] = (uint8_t)val;
4632 size++;
4633 }
4634 }
4635 staticInfo.update(ANDROID_CONTROL_AVAILABLE_EFFECTS,
4636 avail_effects,
4637 size);
4638
4639 uint8_t avail_scene_modes[CAM_SCENE_MODE_MAX];
4640 uint8_t supported_indexes[CAM_SCENE_MODE_MAX];
4641 int32_t supported_scene_modes_cnt = 0;
4642 for (int i = 0; i < gCamCapability[cameraId]->supported_scene_modes_cnt; i++) {
4643 int32_t val = lookupFwkName(SCENE_MODES_MAP,
4644 sizeof(SCENE_MODES_MAP)/sizeof(SCENE_MODES_MAP[0]),
4645 gCamCapability[cameraId]->supported_scene_modes[i]);
4646 if (val != NAME_NOT_FOUND) {
4647 avail_scene_modes[supported_scene_modes_cnt] = (uint8_t)val;
4648 supported_indexes[supported_scene_modes_cnt] = i;
4649 supported_scene_modes_cnt++;
4650 }
4651 }
4652
4653 staticInfo.update(ANDROID_CONTROL_AVAILABLE_SCENE_MODES,
4654 avail_scene_modes,
4655 supported_scene_modes_cnt);
4656
4657 uint8_t scene_mode_overrides[CAM_SCENE_MODE_MAX * 3];
4658 makeOverridesList(gCamCapability[cameraId]->scene_mode_overrides,
4659 supported_scene_modes_cnt,
4660 scene_mode_overrides,
4661 supported_indexes,
4662 cameraId);
4663 staticInfo.update(ANDROID_CONTROL_SCENE_MODE_OVERRIDES,
4664 scene_mode_overrides,
4665 supported_scene_modes_cnt*3);
4666
4667 uint8_t available_control_modes[] = {ANDROID_CONTROL_MODE_OFF,
4668 ANDROID_CONTROL_MODE_AUTO,
4669 ANDROID_CONTROL_MODE_USE_SCENE_MODE};
4670 staticInfo.update(ANDROID_CONTROL_AVAILABLE_MODES,
4671 available_control_modes,
4672 3);
4673
4674 uint8_t avail_antibanding_modes[CAM_ANTIBANDING_MODE_MAX];
4675 size = 0;
4676 for (int i = 0; i < gCamCapability[cameraId]->supported_antibandings_cnt; i++) {
4677 int32_t val = lookupFwkName(ANTIBANDING_MODES_MAP,
4678 sizeof(ANTIBANDING_MODES_MAP)/sizeof(ANTIBANDING_MODES_MAP[0]),
4679 gCamCapability[cameraId]->supported_antibandings[i]);
4680 if (val != NAME_NOT_FOUND) {
4681 avail_antibanding_modes[size] = (uint8_t)val;
4682 size++;
4683 }
4684
4685 }
4686 staticInfo.update(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES,
4687 avail_antibanding_modes,
4688 size);
4689
4690 uint8_t avail_abberation_modes[CAM_COLOR_CORRECTION_ABERRATION_MAX];
4691 size = 0;
4692 if (0 == gCamCapability[cameraId]->aberration_modes_count) {
4693 avail_abberation_modes[0] =
4694 ANDROID_COLOR_CORRECTION_ABERRATION_MODE_OFF;
4695 size++;
4696 } else {
4697 for (size_t i = 0; i < gCamCapability[cameraId]->aberration_modes_count; i++) {
4698 int32_t val = lookupFwkName(COLOR_ABERRATION_MAP,
4699 sizeof(COLOR_ABERRATION_MAP)/sizeof(COLOR_ABERRATION_MAP[0]),
4700 gCamCapability[cameraId]->aberration_modes[i]);
4701 if (val != NAME_NOT_FOUND) {
4702 avail_abberation_modes[size] = (uint8_t)val;
4703 size++;
4704 } else {
4705 ALOGE("%s: Invalid CAC mode %d", __func__,
4706 gCamCapability[cameraId]->aberration_modes[i]);
4707 break;
4708 }
4709 }
4710
4711 }
4712 staticInfo.update(ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES,
4713 avail_abberation_modes,
4714 size);
4715
4716 char cafProp[PROPERTY_VALUE_MAX];
4717 memset(cafProp, 0, sizeof(cafProp));
4718 property_get("persist.camera.caf.disable", cafProp, "0");
4719 uint8_t cafDisabled = atoi(cafProp);
4720
4721 uint8_t avail_af_modes[CAM_FOCUS_MODE_MAX];
4722 size = 0;
4723 for (int i = 0; i < gCamCapability[cameraId]->supported_focus_modes_cnt; i++) {
4724 if (cafDisabled &&
4725 ((gCamCapability[cameraId]->supported_focus_modes[i]
4726 == CAM_FOCUS_MODE_CONTINOUS_PICTURE) ||
4727 (gCamCapability[cameraId]->supported_focus_modes[i]
4728 == CAM_FOCUS_MODE_CONTINOUS_VIDEO)))
4729 continue;
4730
4731 int32_t val = lookupFwkName(FOCUS_MODES_MAP,
4732 sizeof(FOCUS_MODES_MAP)/sizeof(FOCUS_MODES_MAP[0]),
4733 gCamCapability[cameraId]->supported_focus_modes[i]);
4734 if (val != NAME_NOT_FOUND) {
4735 avail_af_modes[size] = (uint8_t)val;
4736 size++;
4737 }
4738 }
4739 staticInfo.update(ANDROID_CONTROL_AF_AVAILABLE_MODES,
4740 avail_af_modes,
4741 size);
4742
4743 uint8_t avail_awb_modes[CAM_WB_MODE_MAX];
4744 size = 0;
4745 for (int i = 0; i < gCamCapability[cameraId]->supported_white_balances_cnt; i++) {
4746 int32_t val = lookupFwkName(WHITE_BALANCE_MODES_MAP,
4747 sizeof(WHITE_BALANCE_MODES_MAP)/sizeof(WHITE_BALANCE_MODES_MAP[0]),
4748 gCamCapability[cameraId]->supported_white_balances[i]);
4749 if (val != NAME_NOT_FOUND) {
4750 avail_awb_modes[size] = (uint8_t)val;
4751 size++;
4752 }
4753 }
4754 staticInfo.update(ANDROID_CONTROL_AWB_AVAILABLE_MODES,
4755 avail_awb_modes,
4756 size);
4757
4758 uint8_t available_flash_levels[CAM_FLASH_FIRING_LEVEL_MAX];
4759 for (int i = 0; i < gCamCapability[cameraId]->supported_flash_firing_level_cnt; i++)
4760 available_flash_levels[i] = gCamCapability[cameraId]->supported_firing_levels[i];
4761
4762 staticInfo.update(ANDROID_FLASH_FIRING_POWER,
4763 available_flash_levels,
4764 gCamCapability[cameraId]->supported_flash_firing_level_cnt);
4765
4766 uint8_t flashAvailable;
4767 if (gCamCapability[cameraId]->flash_available)
4768 flashAvailable = ANDROID_FLASH_INFO_AVAILABLE_TRUE;
4769 else
4770 flashAvailable = ANDROID_FLASH_INFO_AVAILABLE_FALSE;
4771 staticInfo.update(ANDROID_FLASH_INFO_AVAILABLE,
4772 &flashAvailable, 1);
4773
4774 uint8_t avail_ae_modes[5];
4775 size = 0;
4776 for (int i = 0; i < gCamCapability[cameraId]->supported_ae_modes_cnt; i++) {
4777 avail_ae_modes[i] = gCamCapability[cameraId]->supported_ae_modes[i];
4778 size++;
4779 }
4780 if (flashAvailable) {
4781 avail_ae_modes[size++] = ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH;
4782 avail_ae_modes[size++] = ANDROID_CONTROL_AE_MODE_ON_ALWAYS_FLASH;
4783 }
4784 staticInfo.update(ANDROID_CONTROL_AE_AVAILABLE_MODES,
4785 avail_ae_modes,
4786 size);
4787
4788 int32_t sensitivity_range[2];
4789 sensitivity_range[0] = gCamCapability[cameraId]->sensitivity_range.min_sensitivity;
4790 sensitivity_range[1] = gCamCapability[cameraId]->sensitivity_range.max_sensitivity;
4791 staticInfo.update(ANDROID_SENSOR_INFO_SENSITIVITY_RANGE,
4792 sensitivity_range,
4793 sizeof(sensitivity_range) / sizeof(int32_t));
4794
4795 staticInfo.update(ANDROID_SENSOR_MAX_ANALOG_SENSITIVITY,
4796 &gCamCapability[cameraId]->max_analog_sensitivity,
4797 1);
4798
4799 int32_t sensor_orientation = (int32_t)gCamCapability[cameraId]->sensor_mount_angle;
4800 staticInfo.update(ANDROID_SENSOR_ORIENTATION,
4801 &sensor_orientation,
4802 1);
4803
4804 int32_t max_output_streams[3] = {
4805 MAX_STALLING_STREAMS,
4806 MAX_PROCESSED_STREAMS,
4807 MAX_RAW_STREAMS};
4808 staticInfo.update(ANDROID_REQUEST_MAX_NUM_OUTPUT_STREAMS,
4809 max_output_streams,
4810 3);
4811
4812 uint8_t avail_leds = 0;
4813 staticInfo.update(ANDROID_LED_AVAILABLE_LEDS,
4814 &avail_leds, 0);
4815
4816 uint8_t focus_dist_calibrated;
4817 int32_t val = lookupFwkName(FOCUS_CALIBRATION_MAP,
4818 sizeof(FOCUS_CALIBRATION_MAP)/sizeof(FOCUS_CALIBRATION_MAP[0]),
4819 gCamCapability[cameraId]->focus_dist_calibrated);
4820 if (val != NAME_NOT_FOUND) {
4821 focus_dist_calibrated = (uint8_t)val;
4822 staticInfo.update(ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION,
4823 &focus_dist_calibrated, 1);
4824 }
4825
4826 int32_t avail_testpattern_modes[MAX_TEST_PATTERN_CNT];
4827 size = 0;
4828 for (int i = 0; i < gCamCapability[cameraId]->supported_test_pattern_modes_cnt;
4829 i++) {
4830 int32_t val = lookupFwkName(TEST_PATTERN_MAP,
4831 sizeof(TEST_PATTERN_MAP)/sizeof(TEST_PATTERN_MAP[0]),
4832 gCamCapability[cameraId]->supported_test_pattern_modes[i]);
4833 if (val != NAME_NOT_FOUND) {
4834 avail_testpattern_modes[size] = val;
4835 size++;
4836 }
4837 }
4838 staticInfo.update(ANDROID_SENSOR_AVAILABLE_TEST_PATTERN_MODES,
4839 avail_testpattern_modes,
4840 size);
4841
4842 uint8_t max_pipeline_depth = MAX_INFLIGHT_REQUESTS + EMPTY_PIPELINE_DELAY + FRAME_SKIP_DELAY;
4843 staticInfo.update(ANDROID_REQUEST_PIPELINE_MAX_DEPTH,
4844 &max_pipeline_depth,
4845 1);
4846
4847 int32_t partial_result_count = PARTIAL_RESULT_COUNT;
4848 staticInfo.update(ANDROID_REQUEST_PARTIAL_RESULT_COUNT,
4849 &partial_result_count,
4850 1);
4851
4852 int32_t max_stall_duration = MAX_REPROCESS_STALL;
4853 staticInfo.update(ANDROID_REPROCESS_MAX_CAPTURE_STALL, &max_stall_duration, 1);
4854
4855 uint8_t available_capabilities[MAX_AVAILABLE_CAPABILITIES];
4856 uint8_t available_capabilities_count = 0;
4857 available_capabilities[available_capabilities_count++] = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE;
4858 available_capabilities[available_capabilities_count++] = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_SENSOR;
4859 available_capabilities[available_capabilities_count++] = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MANUAL_POST_PROCESSING;
4860 available_capabilities[available_capabilities_count++] = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_READ_SENSOR_SETTINGS;
4861 available_capabilities[available_capabilities_count++] = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BURST_CAPTURE;
4862 if (facingBack) {
4863 available_capabilities[available_capabilities_count++] = ANDROID_REQUEST_AVAILABLE_CAPABILITIES_RAW;
4864 }
4865 staticInfo.update(ANDROID_REQUEST_AVAILABLE_CAPABILITIES,
4866 available_capabilities,
4867 available_capabilities_count);
4868
4869 int32_t max_input_streams = 0;
4870 staticInfo.update(ANDROID_REQUEST_MAX_NUM_INPUT_STREAMS,
4871 &max_input_streams,
4872 1);
4873
4874 int32_t io_format_map[] = {};
4875 ;
4876 staticInfo.update(ANDROID_SCALER_AVAILABLE_INPUT_OUTPUT_FORMATS_MAP,
4877 io_format_map, 0);
4878
4879 int32_t max_latency = (facingBack)? ANDROID_SYNC_MAX_LATENCY_PER_FRAME_CONTROL:CAM_MAX_SYNC_LATENCY;
4880 staticInfo.update(ANDROID_SYNC_MAX_LATENCY,
4881 &max_latency,
4882 1);
4883
4884 uint8_t available_hot_pixel_modes[] = {ANDROID_HOT_PIXEL_MODE_FAST,
4885 ANDROID_HOT_PIXEL_MODE_HIGH_QUALITY};
4886 staticInfo.update(ANDROID_HOT_PIXEL_AVAILABLE_HOT_PIXEL_MODES,
4887 available_hot_pixel_modes,
4888 2);
4889
4890 uint8_t available_shading_modes[] = {ANDROID_SHADING_MODE_OFF,
4891 ANDROID_SHADING_MODE_FAST,
4892 ANDROID_SHADING_MODE_HIGH_QUALITY};
4893 staticInfo.update(ANDROID_SHADING_AVAILABLE_MODES,
4894 available_shading_modes,
4895 3);
4896
4897 uint8_t available_lens_shading_map_modes[] = {ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_OFF,
4898 ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_ON};
4899 staticInfo.update(ANDROID_STATISTICS_INFO_AVAILABLE_LENS_SHADING_MAP_MODES,
4900 available_lens_shading_map_modes,
4901 2);
4902
4903 uint8_t available_edge_modes[] = {ANDROID_EDGE_MODE_OFF,
4904 ANDROID_EDGE_MODE_FAST,
4905 ANDROID_EDGE_MODE_HIGH_QUALITY};
4906 staticInfo.update(ANDROID_EDGE_AVAILABLE_EDGE_MODES,
4907 available_edge_modes,
4908 3);
4909
4910 uint8_t available_noise_red_modes[] = {ANDROID_NOISE_REDUCTION_MODE_OFF,
4911 ANDROID_NOISE_REDUCTION_MODE_FAST,
4912 ANDROID_NOISE_REDUCTION_MODE_HIGH_QUALITY,
4913 ANDROID_NOISE_REDUCTION_MODE_MINIMAL};
4914 staticInfo.update(ANDROID_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES,
4915 available_noise_red_modes,
4916 4);
4917
4918 uint8_t available_tonemap_modes[] = {ANDROID_TONEMAP_MODE_CONTRAST_CURVE,
4919 ANDROID_TONEMAP_MODE_FAST,
4920 ANDROID_TONEMAP_MODE_HIGH_QUALITY};
4921 staticInfo.update(ANDROID_TONEMAP_AVAILABLE_TONE_MAP_MODES,
4922 available_tonemap_modes,
4923 3);
4924
4925 uint8_t available_hot_pixel_map_modes[] = {ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE_OFF};
4926 staticInfo.update(ANDROID_STATISTICS_INFO_AVAILABLE_HOT_PIXEL_MAP_MODES,
4927 available_hot_pixel_map_modes,
4928 1);
4929
4930 uint8_t fwkReferenceIlluminant = lookupFwkName(REFERENCE_ILLUMINANT_MAP,
4931 sizeof(REFERENCE_ILLUMINANT_MAP) / sizeof(REFERENCE_ILLUMINANT_MAP[0]),
4932 gCamCapability[cameraId]->reference_illuminant1);
4933 staticInfo.update(ANDROID_SENSOR_REFERENCE_ILLUMINANT1,
4934 &fwkReferenceIlluminant, 1);
4935
4936 fwkReferenceIlluminant = lookupFwkName(REFERENCE_ILLUMINANT_MAP,
4937 sizeof(REFERENCE_ILLUMINANT_MAP) / sizeof(REFERENCE_ILLUMINANT_MAP[0]),
4938 gCamCapability[cameraId]->reference_illuminant2);
4939 staticInfo.update(ANDROID_SENSOR_REFERENCE_ILLUMINANT2,
4940 &fwkReferenceIlluminant, 1);
4941
4942 staticInfo.update(ANDROID_SENSOR_FORWARD_MATRIX1,
4943 (camera_metadata_rational_t*)gCamCapability[cameraId]->forward_matrix1,
4944 3*3);
4945
4946 staticInfo.update(ANDROID_SENSOR_FORWARD_MATRIX2,
4947 (camera_metadata_rational_t*)gCamCapability[cameraId]->forward_matrix2,
4948 3*3);
4949
4950 staticInfo.update(ANDROID_SENSOR_COLOR_TRANSFORM1,
4951 (camera_metadata_rational_t*) gCamCapability[cameraId]->color_transform1,
4952 3*3);
4953
4954 staticInfo.update(ANDROID_SENSOR_COLOR_TRANSFORM2,
4955 (camera_metadata_rational_t*) gCamCapability[cameraId]->color_transform2,
4956 3*3);
4957
4958 staticInfo.update(ANDROID_SENSOR_CALIBRATION_TRANSFORM1,
4959 (camera_metadata_rational_t*) gCamCapability[cameraId]->calibration_transform1,
4960 3*3);
4961
4962 staticInfo.update(ANDROID_SENSOR_CALIBRATION_TRANSFORM2,
4963 (camera_metadata_rational_t*) gCamCapability[cameraId]->calibration_transform2,
4964 3*3);
4965
4966 int32_t request_keys_basic[] = {ANDROID_COLOR_CORRECTION_MODE,
4967 ANDROID_COLOR_CORRECTION_TRANSFORM, ANDROID_COLOR_CORRECTION_GAINS,
4968 ANDROID_COLOR_CORRECTION_ABERRATION_MODE,
4969 ANDROID_CONTROL_AE_ANTIBANDING_MODE, ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION,
4970 ANDROID_CONTROL_AE_LOCK, ANDROID_CONTROL_AE_MODE,
4971 ANDROID_CONTROL_AE_REGIONS, ANDROID_CONTROL_AE_TARGET_FPS_RANGE,
4972 ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER, ANDROID_CONTROL_AF_MODE,
4973 ANDROID_CONTROL_AF_TRIGGER, ANDROID_CONTROL_AWB_LOCK,
4974 ANDROID_CONTROL_AWB_MODE, ANDROID_CONTROL_CAPTURE_INTENT,
4975 ANDROID_CONTROL_EFFECT_MODE, ANDROID_CONTROL_MODE,
4976 ANDROID_CONTROL_SCENE_MODE, ANDROID_CONTROL_VIDEO_STABILIZATION_MODE,
4977 ANDROID_DEMOSAIC_MODE, ANDROID_EDGE_MODE, ANDROID_EDGE_STRENGTH,
4978 ANDROID_FLASH_FIRING_POWER, ANDROID_FLASH_FIRING_TIME, ANDROID_FLASH_MODE,
4979 ANDROID_JPEG_GPS_COORDINATES,
4980 ANDROID_JPEG_GPS_PROCESSING_METHOD, ANDROID_JPEG_GPS_TIMESTAMP,
4981 ANDROID_JPEG_ORIENTATION, ANDROID_JPEG_QUALITY, ANDROID_JPEG_THUMBNAIL_QUALITY,
4982 ANDROID_JPEG_THUMBNAIL_SIZE, ANDROID_LENS_APERTURE, ANDROID_LENS_FILTER_DENSITY,
4983 ANDROID_LENS_FOCAL_LENGTH, ANDROID_LENS_FOCUS_DISTANCE,
4984 ANDROID_LENS_OPTICAL_STABILIZATION_MODE, ANDROID_NOISE_REDUCTION_MODE,
4985 ANDROID_NOISE_REDUCTION_STRENGTH, ANDROID_REQUEST_ID, ANDROID_REQUEST_TYPE,
4986 ANDROID_SCALER_CROP_REGION, ANDROID_SENSOR_EXPOSURE_TIME,
4987 ANDROID_SENSOR_FRAME_DURATION, ANDROID_HOT_PIXEL_MODE,
4988 ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE,
4989 ANDROID_SENSOR_SENSITIVITY, ANDROID_SHADING_MODE,
4990 ANDROID_SHADING_STRENGTH, ANDROID_STATISTICS_FACE_DETECT_MODE,
4991 ANDROID_STATISTICS_HISTOGRAM_MODE, ANDROID_STATISTICS_SHARPNESS_MAP_MODE,
4992 ANDROID_STATISTICS_LENS_SHADING_MAP_MODE, ANDROID_TONEMAP_CURVE_BLUE,
4993 ANDROID_TONEMAP_CURVE_GREEN, ANDROID_TONEMAP_CURVE_RED, ANDROID_TONEMAP_MODE,
4994 ANDROID_BLACK_LEVEL_LOCK };
4995
4996 size_t request_keys_cnt =
4997 sizeof(request_keys_basic)/sizeof(request_keys_basic[0]);
4998 //NOTE: Please increase available_request_keys array size before
4999 //adding any new entries.
5000 int32_t available_request_keys[request_keys_cnt+1];
5001 memcpy(available_request_keys, request_keys_basic,
5002 sizeof(request_keys_basic));
5003 if (gCamCapability[cameraId]->supported_focus_modes_cnt > 1) {
5004 available_request_keys[request_keys_cnt++] =
5005 ANDROID_CONTROL_AF_REGIONS;
5006 }
5007 //NOTE: Please increase available_request_keys array size before
5008 //adding any new entries.
5009 staticInfo.update(ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS,
5010 available_request_keys, request_keys_cnt);
5011
5012 int32_t result_keys_basic[] = {ANDROID_COLOR_CORRECTION_TRANSFORM,
5013 ANDROID_COLOR_CORRECTION_GAINS, ANDROID_CONTROL_AE_MODE, ANDROID_CONTROL_AE_REGIONS,
5014 ANDROID_CONTROL_AE_STATE, ANDROID_CONTROL_AF_MODE,
5015 ANDROID_CONTROL_AF_STATE, ANDROID_CONTROL_AWB_MODE,
5016 ANDROID_CONTROL_AWB_STATE, ANDROID_CONTROL_MODE, ANDROID_EDGE_MODE,
5017 ANDROID_FLASH_FIRING_POWER, ANDROID_FLASH_FIRING_TIME, ANDROID_FLASH_MODE,
5018 ANDROID_FLASH_STATE, ANDROID_JPEG_GPS_COORDINATES, ANDROID_JPEG_GPS_PROCESSING_METHOD,
5019 ANDROID_JPEG_GPS_TIMESTAMP, ANDROID_JPEG_ORIENTATION, ANDROID_JPEG_QUALITY,
5020 ANDROID_JPEG_THUMBNAIL_QUALITY, ANDROID_JPEG_THUMBNAIL_SIZE, ANDROID_LENS_APERTURE,
5021 ANDROID_LENS_FILTER_DENSITY, ANDROID_LENS_FOCAL_LENGTH, ANDROID_LENS_FOCUS_DISTANCE,
5022 ANDROID_LENS_FOCUS_RANGE, ANDROID_LENS_STATE, ANDROID_LENS_OPTICAL_STABILIZATION_MODE,
5023 ANDROID_NOISE_REDUCTION_MODE, ANDROID_REQUEST_ID,
5024 ANDROID_SCALER_CROP_REGION, ANDROID_SHADING_MODE, ANDROID_SENSOR_EXPOSURE_TIME,
5025 ANDROID_SENSOR_FRAME_DURATION, ANDROID_SENSOR_SENSITIVITY,
5026 ANDROID_SENSOR_TIMESTAMP, ANDROID_SENSOR_NEUTRAL_COLOR_POINT,
5027 ANDROID_SENSOR_PROFILE_TONE_CURVE, ANDROID_BLACK_LEVEL_LOCK, ANDROID_TONEMAP_CURVE_BLUE,
5028 ANDROID_TONEMAP_CURVE_GREEN, ANDROID_TONEMAP_CURVE_RED, ANDROID_TONEMAP_MODE,
5029 ANDROID_STATISTICS_FACE_DETECT_MODE, ANDROID_STATISTICS_HISTOGRAM_MODE,
5030 ANDROID_STATISTICS_SHARPNESS_MAP, ANDROID_STATISTICS_SHARPNESS_MAP_MODE,
5031 ANDROID_STATISTICS_PREDICTED_COLOR_GAINS, ANDROID_STATISTICS_PREDICTED_COLOR_TRANSFORM,
5032 ANDROID_STATISTICS_SCENE_FLICKER, ANDROID_STATISTICS_FACE_IDS,
5033 ANDROID_STATISTICS_FACE_LANDMARKS, ANDROID_STATISTICS_FACE_RECTANGLES,
5034 ANDROID_STATISTICS_FACE_SCORES};
5035 size_t result_keys_cnt =
5036 sizeof(result_keys_basic)/sizeof(result_keys_basic[0]);
5037 //NOTE: Please increase available_result_keys array size before
5038 //adding any new entries.
5039 int32_t available_result_keys[result_keys_cnt+3];
5040 memcpy(available_result_keys, result_keys_basic,
5041 sizeof(result_keys_basic));
5042 if (gCamCapability[cameraId]->supported_focus_modes_cnt > 1) {
5043 available_result_keys[result_keys_cnt++] =
5044 ANDROID_CONTROL_AF_REGIONS;
5045 }
5046 if (facingBack) {
5047 available_result_keys[result_keys_cnt++] = ANDROID_SENSOR_NOISE_PROFILE;
5048 available_result_keys[result_keys_cnt++] = ANDROID_SENSOR_GREEN_SPLIT;
5049 }
5050 //NOTE: Please increase available_result_keys array size before
5051 //adding any new entries.
5052
5053 staticInfo.update(ANDROID_REQUEST_AVAILABLE_RESULT_KEYS,
5054 available_result_keys, result_keys_cnt);
5055
5056 int32_t available_characteristics_keys[] = {ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES,
5057 ANDROID_CONTROL_AE_AVAILABLE_MODES, ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
5058 ANDROID_CONTROL_AE_COMPENSATION_RANGE, ANDROID_CONTROL_AE_COMPENSATION_STEP,
5059 ANDROID_CONTROL_AF_AVAILABLE_MODES, ANDROID_CONTROL_AVAILABLE_EFFECTS,
5060 ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES,
5061 ANDROID_SCALER_CROPPING_TYPE,
5062 ANDROID_SENSOR_INFO_TIMESTAMP_SOURCE,
5063 ANDROID_SYNC_MAX_LATENCY,
5064 ANDROID_CONTROL_AVAILABLE_SCENE_MODES,
5065 ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES,
5066 ANDROID_CONTROL_AWB_AVAILABLE_MODES, ANDROID_CONTROL_MAX_REGIONS,
5067 ANDROID_CONTROL_SCENE_MODE_OVERRIDES,ANDROID_FLASH_INFO_AVAILABLE,
5068 ANDROID_FLASH_INFO_CHARGE_DURATION, ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES,
5069 ANDROID_JPEG_MAX_SIZE, ANDROID_LENS_INFO_AVAILABLE_APERTURES,
5070 ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES,
5071 ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS,
5072 ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION,
5073 ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE, ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE,
5074 ANDROID_LENS_INFO_SHADING_MAP_SIZE, ANDROID_LENS_INFO_FOCUS_DISTANCE_CALIBRATION,
5075 ANDROID_LENS_FACING,
5076 ANDROID_REQUEST_MAX_NUM_OUTPUT_STREAMS, ANDROID_REQUEST_MAX_NUM_INPUT_STREAMS,
5077 ANDROID_REQUEST_PIPELINE_MAX_DEPTH, ANDROID_REQUEST_AVAILABLE_CAPABILITIES,
5078 ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS, ANDROID_REQUEST_AVAILABLE_RESULT_KEYS,
5079 ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS, ANDROID_REQUEST_PARTIAL_RESULT_COUNT,
5080 ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM,
5081 ANDROID_SCALER_AVAILABLE_INPUT_OUTPUT_FORMATS_MAP,
5082 ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS,
5083 /*ANDROID_SCALER_AVAILABLE_STALL_DURATIONS,*/
5084 ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS, ANDROID_SENSOR_FORWARD_MATRIX1,
5085 ANDROID_SENSOR_REFERENCE_ILLUMINANT1, ANDROID_SENSOR_REFERENCE_ILLUMINANT2,
5086 ANDROID_SENSOR_FORWARD_MATRIX2, ANDROID_SENSOR_COLOR_TRANSFORM1,
5087 ANDROID_SENSOR_COLOR_TRANSFORM2, ANDROID_SENSOR_CALIBRATION_TRANSFORM1,
5088 ANDROID_SENSOR_CALIBRATION_TRANSFORM2, ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE,
5089 ANDROID_SENSOR_INFO_SENSITIVITY_RANGE, ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT,
5090 ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE, ANDROID_SENSOR_INFO_MAX_FRAME_DURATION,
5091 ANDROID_SENSOR_INFO_PHYSICAL_SIZE, ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE,
5092 ANDROID_SENSOR_INFO_WHITE_LEVEL, ANDROID_SENSOR_BASE_GAIN_FACTOR,
5093 ANDROID_SENSOR_BLACK_LEVEL_PATTERN, ANDROID_SENSOR_MAX_ANALOG_SENSITIVITY,
5094 ANDROID_SENSOR_ORIENTATION, ANDROID_SENSOR_AVAILABLE_TEST_PATTERN_MODES,
5095 ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES,
5096 ANDROID_STATISTICS_INFO_HISTOGRAM_BUCKET_COUNT,
5097 ANDROID_STATISTICS_INFO_MAX_FACE_COUNT, ANDROID_STATISTICS_INFO_MAX_HISTOGRAM_COUNT,
5098 ANDROID_STATISTICS_INFO_MAX_SHARPNESS_MAP_VALUE,
5099 ANDROID_STATISTICS_INFO_SHARPNESS_MAP_SIZE, ANDROID_HOT_PIXEL_AVAILABLE_HOT_PIXEL_MODES,
5100 ANDROID_EDGE_AVAILABLE_EDGE_MODES,
5101 ANDROID_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES,
5102 ANDROID_TONEMAP_AVAILABLE_TONE_MAP_MODES,
5103 ANDROID_STATISTICS_INFO_AVAILABLE_HOT_PIXEL_MAP_MODES,
5104 ANDROID_TONEMAP_MAX_CURVE_POINTS,
5105 ANDROID_CONTROL_AVAILABLE_MODES,
5106 ANDROID_CONTROL_AE_LOCK_AVAILABLE,
5107 ANDROID_CONTROL_AWB_LOCK_AVAILABLE,
5108 ANDROID_STATISTICS_INFO_AVAILABLE_LENS_SHADING_MAP_MODES,
5109 ANDROID_SHADING_AVAILABLE_MODES,
5110 ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL };
5111 staticInfo.update(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS,
5112 available_characteristics_keys,
5113 sizeof(available_characteristics_keys)/sizeof(int32_t));
5114
5115 /*available stall durations depend on the hw + sw and will be different for different devices */
5116 /*have to add for raw after implementation*/
5117 int32_t stall_formats[] = {HAL_PIXEL_FORMAT_BLOB, ANDROID_SCALER_AVAILABLE_FORMATS_RAW16};
5118 size_t stall_formats_count = sizeof(stall_formats)/sizeof(int32_t);
5119
5120 size_t available_stall_size = gCamCapability[cameraId]->picture_sizes_tbl_cnt * 4;
5121 int64_t available_stall_durations[available_stall_size];
5122 idx = 0;
5123 for (uint32_t j = 0; j < stall_formats_count; j++) {
5124 if (stall_formats[j] == HAL_PIXEL_FORMAT_BLOB) {
5125 for (uint32_t i = 0; i < gCamCapability[cameraId]->picture_sizes_tbl_cnt; i++) {
5126 available_stall_durations[idx] = stall_formats[j];
5127 available_stall_durations[idx+1] = gCamCapability[cameraId]->picture_sizes_tbl[i].width;
5128 available_stall_durations[idx+2] = gCamCapability[cameraId]->picture_sizes_tbl[i].height;
5129 available_stall_durations[idx+3] = gCamCapability[cameraId]->jpeg_stall_durations[i];
5130 idx+=4;
5131 }
5132 } else {
5133 for (uint32_t i = 0; i < gCamCapability[cameraId]->supported_raw_dim_cnt; i++) {
5134 available_stall_durations[idx] = stall_formats[j];
5135 available_stall_durations[idx+1] = gCamCapability[cameraId]->raw_dim[i].width;
5136 available_stall_durations[idx+2] = gCamCapability[cameraId]->raw_dim[i].height;
5137 available_stall_durations[idx+3] = gCamCapability[cameraId]->raw16_stall_durations[i];
5138 idx+=4;
5139 }
5140 }
5141 }
5142 staticInfo.update(ANDROID_SCALER_AVAILABLE_STALL_DURATIONS,
5143 available_stall_durations,
5144 idx);
5145 //QCAMERA3_OPAQUE_RAW
5146 uint8_t raw_format = QCAMERA3_OPAQUE_RAW_FORMAT_LEGACY;
5147 cam_format_t fmt = CAM_FORMAT_BAYER_QCOM_RAW_10BPP_GBRG;
5148 switch (gCamCapability[cameraId]->opaque_raw_fmt) {
5149 case LEGACY_RAW:
5150 if (gCamCapability[cameraId]->white_level == (1<<8)-1)
5151 fmt = CAM_FORMAT_BAYER_QCOM_RAW_8BPP_GBRG;
5152 else if (gCamCapability[cameraId]->white_level == (1<<10)-1)
5153 fmt = CAM_FORMAT_BAYER_QCOM_RAW_10BPP_GBRG;
5154 else if (gCamCapability[cameraId]->white_level == (1<<12)-1)
5155 fmt = CAM_FORMAT_BAYER_QCOM_RAW_12BPP_GBRG;
5156 raw_format = QCAMERA3_OPAQUE_RAW_FORMAT_LEGACY;
5157 break;
5158 case MIPI_RAW:
5159 if (gCamCapability[cameraId]->white_level == (1<<8)-1)
5160 fmt = CAM_FORMAT_BAYER_MIPI_RAW_8BPP_GBRG;
5161 else if (gCamCapability[cameraId]->white_level == (1<<10)-1)
5162 fmt = CAM_FORMAT_BAYER_MIPI_RAW_10BPP_GBRG;
5163 else if (gCamCapability[cameraId]->white_level == (1<<12)-1)
5164 fmt = CAM_FORMAT_BAYER_MIPI_RAW_12BPP_GBRG;
5165 raw_format = QCAMERA3_OPAQUE_RAW_FORMAT_MIPI;
5166 break;
5167 default:
5168 ALOGE("%s: unknown opaque_raw_format %d", __func__,
5169 gCamCapability[cameraId]->opaque_raw_fmt);
5170 break;
5171 }
5172 staticInfo.update(QCAMERA3_OPAQUE_RAW_FORMAT, &raw_format, 1);
5173
5174 if (gCamCapability[cameraId]->supported_raw_dim_cnt) {
5175 int32_t strides[3*gCamCapability[cameraId]->supported_raw_dim_cnt];
5176 for (size_t i = 0; i < gCamCapability[cameraId]->supported_raw_dim_cnt; i++) {
5177 cam_stream_buf_plane_info_t buf_planes;
5178 strides[i*3] = gCamCapability[cameraId]->raw_dim[i].width;
5179 strides[i*3+1] = gCamCapability[cameraId]->raw_dim[i].height;
5180 mm_stream_calc_offset_raw(fmt, &gCamCapability[cameraId]->raw_dim[i],
5181 &gCamCapability[cameraId]->padding_info, &buf_planes);
5182 strides[i*3+2] = buf_planes.plane_info.mp[0].stride;
5183 }
5184 staticInfo.update(QCAMERA3_OPAQUE_RAW_STRIDES, strides,
5185 3*gCamCapability[cameraId]->supported_raw_dim_cnt);
5186 }
5187 gStaticMetadata[cameraId] = staticInfo.release();
5188 return rc;
5189 }
5190
5191 /*===========================================================================
5192 * FUNCTION : makeTable
5193 *
5194 * DESCRIPTION: make a table of sizes
5195 *
5196 * PARAMETERS :
5197 *
5198 *
5199 *==========================================================================*/
makeTable(cam_dimension_t * dimTable,uint8_t size,int32_t * sizeTable)5200 void QCamera3HardwareInterface::makeTable(cam_dimension_t* dimTable, uint8_t size,
5201 int32_t* sizeTable)
5202 {
5203 int j = 0;
5204 for (int i = 0; i < size; i++) {
5205 sizeTable[j] = dimTable[i].width;
5206 sizeTable[j+1] = dimTable[i].height;
5207 j+=2;
5208 }
5209 }
5210
5211 /*===========================================================================
5212 * FUNCTION : makeFPSTable
5213 *
5214 * DESCRIPTION: make a table of fps ranges
5215 *
5216 * PARAMETERS :
5217 *
5218 *==========================================================================*/
makeFPSTable(cam_fps_range_t * fpsTable,uint8_t size,int32_t * fpsRangesTable)5219 void QCamera3HardwareInterface::makeFPSTable(cam_fps_range_t* fpsTable, uint8_t size,
5220 int32_t* fpsRangesTable)
5221 {
5222 int j = 0;
5223 for (int i = 0; i < size; i++) {
5224 fpsRangesTable[j] = (int32_t)fpsTable[i].min_fps;
5225 fpsRangesTable[j+1] = (int32_t)fpsTable[i].max_fps;
5226 j+=2;
5227 }
5228 }
5229
5230 /*===========================================================================
5231 * FUNCTION : makeOverridesList
5232 *
5233 * DESCRIPTION: make a list of scene mode overrides
5234 *
5235 * PARAMETERS :
5236 *
5237 *
5238 *==========================================================================*/
makeOverridesList(cam_scene_mode_overrides_t * overridesTable,uint8_t size,uint8_t * overridesList,uint8_t * supported_indexes,int camera_id)5239 void QCamera3HardwareInterface::makeOverridesList(cam_scene_mode_overrides_t* overridesTable,
5240 uint8_t size, uint8_t* overridesList,
5241 uint8_t* supported_indexes,
5242 int camera_id)
5243 {
5244 /*daemon will give a list of overrides for all scene modes.
5245 However we should send the fwk only the overrides for the scene modes
5246 supported by the framework*/
5247 int j = 0, index = 0, supt = 0;
5248 uint8_t focus_override;
5249 for (int i = 0; i < size; i++) {
5250 supt = 0;
5251 index = supported_indexes[i];
5252 overridesList[j] = gCamCapability[camera_id]->flash_available ? ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH:ANDROID_CONTROL_AE_MODE_ON;
5253 overridesList[j+1] = (uint8_t)lookupFwkName(WHITE_BALANCE_MODES_MAP,
5254 sizeof(WHITE_BALANCE_MODES_MAP)/sizeof(WHITE_BALANCE_MODES_MAP[0]),
5255 overridesTable[index].awb_mode);
5256 focus_override = (uint8_t)overridesTable[index].af_mode;
5257 for (int k = 0; k < gCamCapability[camera_id]->supported_focus_modes_cnt; k++) {
5258 if (gCamCapability[camera_id]->supported_focus_modes[k] == focus_override) {
5259 supt = 1;
5260 break;
5261 }
5262 }
5263 if (supt) {
5264 overridesList[j+2] = (uint8_t)lookupFwkName(FOCUS_MODES_MAP,
5265 sizeof(FOCUS_MODES_MAP)/sizeof(FOCUS_MODES_MAP[0]),
5266 focus_override);
5267 } else {
5268 overridesList[j+2] = ANDROID_CONTROL_AF_MODE_OFF;
5269 }
5270 j+=3;
5271 }
5272 }
5273
5274 /*===========================================================================
5275 * FUNCTION : filterJpegSizes
5276 *
5277 * DESCRIPTION: Returns the supported jpeg sizes based on the max dimension that
5278 * could be downscaled to
5279 *
5280 * PARAMETERS :
5281 *
5282 * RETURN : length of jpegSizes array
5283 *==========================================================================*/
5284
filterJpegSizes(int32_t * jpegSizes,int32_t * processedSizes,uint8_t processedSizesCnt,uint8_t maxCount,cam_rect_t active_array_size,uint8_t downscale_factor)5285 uint8_t QCamera3HardwareInterface::filterJpegSizes(int32_t* jpegSizes, int32_t* processedSizes,
5286 uint8_t processedSizesCnt,
5287 uint8_t maxCount,
5288 cam_rect_t active_array_size,
5289 uint8_t downscale_factor)
5290 {
5291 if (downscale_factor == 0) {
5292 downscale_factor = 1;
5293 }
5294 int32_t min_width = active_array_size.width / downscale_factor;
5295 int32_t min_height = active_array_size.height / downscale_factor;
5296 uint8_t jpegSizesCnt = 0;
5297 if (processedSizesCnt > maxCount) {
5298 processedSizesCnt = maxCount;
5299 }
5300 for (int i = 0; i < processedSizesCnt; i+=2) {
5301 if (processedSizes[i] >= min_width && processedSizes[i+1] >= min_height) {
5302 jpegSizes[jpegSizesCnt] = processedSizes[i];
5303 jpegSizes[jpegSizesCnt+1] = processedSizes[i+1];
5304 jpegSizesCnt += 2;
5305 }
5306 }
5307 return jpegSizesCnt;
5308 }
5309
5310 /*===========================================================================
5311 * FUNCTION : getPreviewHalPixelFormat
5312 *
5313 * DESCRIPTION: convert the format to type recognized by framework
5314 *
5315 * PARAMETERS : format : the format from backend
5316 *
5317 ** RETURN : format recognized by framework
5318 *
5319 *==========================================================================*/
getScalarFormat(int32_t format)5320 int32_t QCamera3HardwareInterface::getScalarFormat(int32_t format)
5321 {
5322 int32_t halPixelFormat;
5323
5324 switch (format) {
5325 case CAM_FORMAT_YUV_420_NV12:
5326 halPixelFormat = HAL_PIXEL_FORMAT_YCbCr_420_SP;
5327 break;
5328 case CAM_FORMAT_YUV_420_NV21:
5329 halPixelFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP;
5330 break;
5331 case CAM_FORMAT_YUV_420_NV21_ADRENO:
5332 halPixelFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO;
5333 break;
5334 case CAM_FORMAT_YUV_420_YV12:
5335 halPixelFormat = HAL_PIXEL_FORMAT_YV12;
5336 break;
5337 case CAM_FORMAT_YUV_422_NV16:
5338 case CAM_FORMAT_YUV_422_NV61:
5339 default:
5340 halPixelFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP;
5341 break;
5342 }
5343 return halPixelFormat;
5344 }
5345 /*===========================================================================
5346 * FUNCTION : computeNoiseModelEntryS
5347 *
5348 * DESCRIPTION: function to map a given sensitivity to the S noise
5349 * model parameters in the DNG noise model.
5350 *
5351 * PARAMETERS : sens : the sensor sensitivity
5352 *
5353 ** RETURN : S (sensor amplification) noise
5354 *
5355 *==========================================================================*/
5356
computeNoiseModelEntryS(int32_t sens)5357 double QCamera3HardwareInterface::computeNoiseModelEntryS(int32_t sens) {
5358 double s = 4.290559e-06 * sens + 4.370087e-05;
5359 return s < 0.0 ? 0.0 : s;
5360 }
5361
5362 /*===========================================================================
5363 * FUNCTION : computeNoiseModelEntryO
5364 *
5365 * DESCRIPTION: function to map a given sensitivity to the O noise
5366 * model parameters in the DNG noise model.
5367 *
5368 * PARAMETERS : sens : the sensor sensitivity
5369 *
5370 ** RETURN : O (sensor readout) noise
5371 *
5372 *==========================================================================*/
5373
computeNoiseModelEntryO(int32_t sens)5374 double QCamera3HardwareInterface::computeNoiseModelEntryO(int32_t sens) {
5375 double digital_gain = sens / 320.0;
5376 digital_gain = digital_gain < 1.0 ? 1.0 : digital_gain;
5377 double o = 6.011498e-11 * sens * sens + 2.173219e-06 * digital_gain * digital_gain;
5378 return o < 0.0 ? 0.0 : o;
5379 }
5380
5381 /*===========================================================================
5382 * FUNCTION : getSensorSensitivity
5383 *
5384 * DESCRIPTION: convert iso_mode to an integer value
5385 *
5386 * PARAMETERS : iso_mode : the iso_mode supported by sensor
5387 *
5388 ** RETURN : sensitivity supported by sensor
5389 *
5390 *==========================================================================*/
getSensorSensitivity(int32_t iso_mode)5391 int32_t QCamera3HardwareInterface::getSensorSensitivity(int32_t iso_mode)
5392 {
5393 int32_t sensitivity;
5394
5395 switch (iso_mode) {
5396 case CAM_ISO_MODE_100:
5397 sensitivity = 100;
5398 break;
5399 case CAM_ISO_MODE_200:
5400 sensitivity = 200;
5401 break;
5402 case CAM_ISO_MODE_400:
5403 sensitivity = 400;
5404 break;
5405 case CAM_ISO_MODE_800:
5406 sensitivity = 800;
5407 break;
5408 case CAM_ISO_MODE_1600:
5409 sensitivity = 1600;
5410 break;
5411 default:
5412 sensitivity = -1;
5413 break;
5414 }
5415 return sensitivity;
5416 }
5417
5418 /*===========================================================================
5419 * FUNCTION : AddSetParmEntryToBatch
5420 *
5421 * DESCRIPTION: add set parameter entry into batch
5422 *
5423 * PARAMETERS :
5424 * @p_table : ptr to parameter buffer
5425 * @paramType : parameter type
5426 * @paramLength : length of parameter value
5427 * @paramValue : ptr to parameter value
5428 *
5429 * RETURN : int32_t type of status
5430 * NO_ERROR -- success
5431 * none-zero failure code
5432 *==========================================================================*/
AddSetParmEntryToBatch(parm_buffer_t * p_table,cam_intf_parm_type_t paramType,uint32_t paramLength,void * paramValue)5433 int32_t QCamera3HardwareInterface::AddSetParmEntryToBatch(parm_buffer_t *p_table,
5434 cam_intf_parm_type_t paramType,
5435 uint32_t paramLength,
5436 void *paramValue)
5437 {
5438 void* dst;
5439 if ((NULL == p_table) || (NULL == paramValue) ||
5440 (paramType >= CAM_INTF_PARM_MAX)) {
5441 ALOGE("%s: Invalid p_table: %p, paramValue: %p, param type: %d",
5442 __func__, p_table, paramValue, paramType);
5443 return BAD_VALUE;
5444 }
5445 /*************************************************************************
5446 * Copy contents into entry *
5447 *************************************************************************/
5448 if (paramLength > get_size_of(paramType)) {
5449 ALOGE("%s: input larger than max entry size, type=%d, length =%d",
5450 __func__, paramType, paramLength);
5451 return BAD_VALUE;
5452 }
5453 dst = get_pointer_of(paramType, p_table);
5454 if(NULL != dst){
5455 memcpy(dst, paramValue, paramLength);
5456 p_table->is_valid[paramType] = 1;
5457 }
5458 return NO_ERROR;
5459 }
5460
5461 /*===========================================================================
5462 * FUNCTION : lookupFwkName
5463 *
5464 * DESCRIPTION: In case the enum is not same in fwk and backend
5465 * make sure the parameter is correctly propogated
5466 *
5467 * PARAMETERS :
5468 * @arr : map between the two enums
5469 * @len : len of the map
5470 * @hal_name : name of the hal_parm to map
5471 *
5472 * RETURN : int type of status
5473 * fwk_name -- success
5474 * none-zero failure code
5475 *==========================================================================*/
lookupFwkName(const QCameraMap arr[],int len,int hal_name)5476 int32_t QCamera3HardwareInterface::lookupFwkName(const QCameraMap arr[],
5477 int len, int hal_name)
5478 {
5479
5480 for (int i = 0; i < len; i++) {
5481 if (arr[i].hal_name == hal_name)
5482 return arr[i].fwk_name;
5483 }
5484
5485 /* Not able to find matching framework type is not necessarily
5486 * an error case. This happens when mm-camera supports more attributes
5487 * than the frameworks do */
5488 CDBG_HIGH("%s: Cannot find matching framework type", __func__);
5489 return NAME_NOT_FOUND;
5490 }
5491
5492 /*===========================================================================
5493 * FUNCTION : lookupHalName
5494 *
5495 * DESCRIPTION: In case the enum is not same in fwk and backend
5496 * make sure the parameter is correctly propogated
5497 *
5498 * PARAMETERS :
5499 * @arr : map between the two enums
5500 * @len : len of the map
5501 * @fwk_name : name of the hal_parm to map
5502 *
5503 * RETURN : int32_t type of status
5504 * hal_name -- success
5505 * none-zero failure code
5506 *==========================================================================*/
lookupHalName(const QCameraMap arr[],int len,unsigned int fwk_name)5507 int8_t QCamera3HardwareInterface::lookupHalName(const QCameraMap arr[],
5508 int len, unsigned int fwk_name)
5509 {
5510 for (int i = 0; i < len; i++) {
5511 if (arr[i].fwk_name == fwk_name)
5512 return arr[i].hal_name;
5513 }
5514 ALOGE("%s: Cannot find matching hal type", __func__);
5515 return NAME_NOT_FOUND;
5516 }
5517
5518 /*===========================================================================
5519 * FUNCTION : lookupProp
5520 *
5521 * DESCRIPTION: lookup a value by its name
5522 *
5523 * PARAMETERS :
5524 * @attr : map contains <name, value>
5525 * @len : size of the map
5526 * @name : name to be looked up
5527 *
5528 * RETURN : Value if found
5529 * CAM_CDS_MODE_MAX if not found
5530 *==========================================================================*/
lookupProp(const QCameraPropMap arr[],int len,const char * name)5531 cam_cds_mode_type_t QCamera3HardwareInterface::lookupProp(const QCameraPropMap arr[],
5532 int len, const char *name)
5533 {
5534 if (name) {
5535 for (int i = 0; i < len; i++) {
5536 if (!strcmp(arr[i].desc, name)) {
5537 return arr[i].val;
5538 }
5539 }
5540 }
5541 return CAM_CDS_MODE_MAX;
5542 }
5543
5544 /*===========================================================================
5545 * FUNCTION : getCapabilities
5546 *
5547 * DESCRIPTION: query camera capabilities
5548 *
5549 * PARAMETERS :
5550 * @cameraId : camera Id
5551 * @info : camera info struct to be filled in with camera capabilities
5552 *
5553 * RETURN : int32_t type of status
5554 * NO_ERROR -- success
5555 * none-zero failure code
5556 *==========================================================================*/
getCamInfo(int cameraId,struct camera_info * info)5557 int QCamera3HardwareInterface::getCamInfo(int cameraId,
5558 struct camera_info *info)
5559 {
5560 ATRACE_CALL();
5561 int rc = 0;
5562
5563 if (NULL == gCamCapability[cameraId]) {
5564 rc = initCapabilities(cameraId);
5565 if (rc < 0) {
5566 //pthread_mutex_unlock(&g_camlock);
5567 return rc;
5568 }
5569 }
5570
5571 if (NULL == gStaticMetadata[cameraId]) {
5572 rc = initStaticMetadata(cameraId);
5573 if (rc < 0) {
5574 return rc;
5575 }
5576 }
5577
5578 switch(gCamCapability[cameraId]->position) {
5579 case CAM_POSITION_BACK:
5580 info->facing = CAMERA_FACING_BACK;
5581 break;
5582
5583 case CAM_POSITION_FRONT:
5584 info->facing = CAMERA_FACING_FRONT;
5585 break;
5586
5587 default:
5588 ALOGE("%s:Unknown position type for camera id:%d", __func__, cameraId);
5589 rc = -1;
5590 break;
5591 }
5592
5593 info->orientation = gCamCapability[cameraId]->sensor_mount_angle;
5594 info->device_version = CAMERA_DEVICE_API_VERSION_3_3;
5595 info->static_camera_characteristics = gStaticMetadata[cameraId];
5596
5597 //For now assume both cameras can operate independently.
5598 info->conflicting_devices = NULL;
5599 info->conflicting_devices_length = 0;
5600
5601 //resource cost is 100 * MIN(1.0, m/M),
5602 //where m is throughput requirement with maximum stream configuration
5603 //and M is CPP maximum throughput.
5604 float max_fps = 0.0;
5605 for (uint32_t i = 0;
5606 i < gCamCapability[cameraId]->fps_ranges_tbl_cnt; i++) {
5607 if (max_fps < gCamCapability[cameraId]->fps_ranges_tbl[i].max_fps)
5608 max_fps = gCamCapability[cameraId]->fps_ranges_tbl[i].max_fps;
5609 }
5610 float ratio = 1.0 * MAX_PROCESSED_STREAMS *
5611 gCamCapability[cameraId]->active_array_size.width *
5612 gCamCapability[cameraId]->active_array_size.height * max_fps /
5613 gCamCapability[cameraId]->max_pixel_bandwidth;
5614 info->resource_cost = 100 * MIN(1.0, ratio);
5615 ALOGI("%s: camera %d resource cost is %d", __func__, cameraId,
5616 info->resource_cost);
5617
5618 return rc;
5619 }
5620
5621 /*===========================================================================
5622 * FUNCTION : translateCapabilityToMetadata
5623 *
5624 * DESCRIPTION: translate the capability into camera_metadata_t
5625 *
5626 * PARAMETERS : type of the request
5627 *
5628 *
5629 * RETURN : success: camera_metadata_t*
5630 * failure: NULL
5631 *
5632 *==========================================================================*/
translateCapabilityToMetadata(int type)5633 camera_metadata_t* QCamera3HardwareInterface::translateCapabilityToMetadata(int type)
5634 {
5635 pthread_mutex_lock(&mMutex);
5636
5637 if (mDefaultMetadata[type] != NULL) {
5638 pthread_mutex_unlock(&mMutex);
5639 return mDefaultMetadata[type];
5640 }
5641 //first time we are handling this request
5642 //fill up the metadata structure using the wrapper class
5643 CameraMetadata settings;
5644 //translate from cam_capability_t to camera_metadata_tag_t
5645 static const uint8_t requestType = ANDROID_REQUEST_TYPE_CAPTURE;
5646 settings.update(ANDROID_REQUEST_TYPE, &requestType, 1);
5647 int32_t defaultRequestID = 0;
5648 settings.update(ANDROID_REQUEST_ID, &defaultRequestID, 1);
5649
5650 /* OIS disable */
5651 char ois_prop[PROPERTY_VALUE_MAX];
5652 memset(ois_prop, 0, sizeof(ois_prop));
5653 property_get("persist.camera.ois.disable", ois_prop, "0");
5654 uint8_t ois_disable = atoi(ois_prop);
5655
5656 /* OIS/EIS disable */
5657 char eis_prop[PROPERTY_VALUE_MAX];
5658 memset(eis_prop, 0, sizeof(eis_prop));
5659 property_get("camera.eis.enable", eis_prop, "0");
5660 mEisEnable = atoi(eis_prop);
5661
5662 /* Force video to use OIS */
5663 char videoOisProp[PROPERTY_VALUE_MAX];
5664 memset(videoOisProp, 0, sizeof(videoOisProp));
5665 property_get("persist.camera.ois.video", videoOisProp, "1");
5666 uint8_t forceVideoOis = atoi(videoOisProp);
5667
5668 uint8_t controlIntent = 0;
5669 uint8_t focusMode;
5670 uint8_t vsMode;
5671 uint8_t optStabMode;
5672 uint8_t cacMode;
5673 uint8_t edge_mode;
5674 uint8_t noise_red_mode;
5675 uint8_t tonemap_mode;
5676 vsMode = ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF;
5677 switch (type) {
5678 case CAMERA3_TEMPLATE_PREVIEW:
5679 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW;
5680 focusMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE;
5681 optStabMode = ANDROID_LENS_OPTICAL_STABILIZATION_MODE_ON;
5682 cacMode = ANDROID_COLOR_CORRECTION_ABERRATION_MODE_FAST;
5683 edge_mode = ANDROID_EDGE_MODE_FAST;
5684 noise_red_mode = ANDROID_NOISE_REDUCTION_MODE_FAST;
5685 tonemap_mode = ANDROID_TONEMAP_MODE_FAST;
5686 break;
5687 case CAMERA3_TEMPLATE_STILL_CAPTURE:
5688 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE;
5689 focusMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE;
5690 optStabMode = ANDROID_LENS_OPTICAL_STABILIZATION_MODE_ON;
5691 cacMode = ANDROID_COLOR_CORRECTION_ABERRATION_MODE_HIGH_QUALITY;
5692 edge_mode = ANDROID_EDGE_MODE_HIGH_QUALITY;
5693 noise_red_mode = ANDROID_NOISE_REDUCTION_MODE_HIGH_QUALITY;
5694 tonemap_mode = ANDROID_TONEMAP_MODE_HIGH_QUALITY;
5695 break;
5696 case CAMERA3_TEMPLATE_VIDEO_RECORD:
5697 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_RECORD;
5698 focusMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO;
5699 optStabMode = ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF;
5700 cacMode = ANDROID_COLOR_CORRECTION_ABERRATION_MODE_FAST;
5701 edge_mode = ANDROID_EDGE_MODE_FAST;
5702 noise_red_mode = ANDROID_NOISE_REDUCTION_MODE_FAST;
5703 tonemap_mode = ANDROID_TONEMAP_MODE_FAST;
5704 if (forceVideoOis)
5705 optStabMode = ANDROID_LENS_OPTICAL_STABILIZATION_MODE_ON;
5706 break;
5707 case CAMERA3_TEMPLATE_VIDEO_SNAPSHOT:
5708 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT;
5709 focusMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO;
5710 optStabMode = ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF;
5711 cacMode = ANDROID_COLOR_CORRECTION_ABERRATION_MODE_FAST;
5712 edge_mode = ANDROID_EDGE_MODE_FAST;
5713 noise_red_mode = ANDROID_NOISE_REDUCTION_MODE_FAST;
5714 tonemap_mode = ANDROID_TONEMAP_MODE_FAST;
5715 if (forceVideoOis)
5716 optStabMode = ANDROID_LENS_OPTICAL_STABILIZATION_MODE_ON;
5717 break;
5718 case CAMERA3_TEMPLATE_ZERO_SHUTTER_LAG:
5719 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_ZERO_SHUTTER_LAG;
5720 focusMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE;
5721 optStabMode = ANDROID_LENS_OPTICAL_STABILIZATION_MODE_ON;
5722 cacMode = ANDROID_COLOR_CORRECTION_ABERRATION_MODE_FAST;
5723 edge_mode = ANDROID_EDGE_MODE_FAST;
5724 noise_red_mode = ANDROID_NOISE_REDUCTION_MODE_FAST;
5725 tonemap_mode = ANDROID_TONEMAP_MODE_FAST;
5726 break;
5727 case CAMERA3_TEMPLATE_MANUAL:
5728 edge_mode = ANDROID_EDGE_MODE_FAST;
5729 noise_red_mode = ANDROID_NOISE_REDUCTION_MODE_FAST;
5730 tonemap_mode = ANDROID_TONEMAP_MODE_FAST;
5731 cacMode = ANDROID_COLOR_CORRECTION_ABERRATION_MODE_FAST;
5732 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_MANUAL;
5733 focusMode = ANDROID_CONTROL_AF_MODE_OFF;
5734 optStabMode = ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF;
5735 break;
5736 default:
5737 edge_mode = ANDROID_EDGE_MODE_FAST;
5738 noise_red_mode = ANDROID_NOISE_REDUCTION_MODE_FAST;
5739 tonemap_mode = ANDROID_TONEMAP_MODE_FAST;
5740 cacMode = ANDROID_COLOR_CORRECTION_ABERRATION_MODE_FAST;
5741 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_CUSTOM;
5742 optStabMode = ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF;
5743 break;
5744 }
5745 settings.update(ANDROID_COLOR_CORRECTION_ABERRATION_MODE, &cacMode, 1);
5746 settings.update(ANDROID_CONTROL_CAPTURE_INTENT, &controlIntent, 1);
5747 settings.update(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE, &vsMode, 1);
5748 if (gCamCapability[mCameraId]->supported_focus_modes_cnt == 1) {
5749 focusMode = ANDROID_CONTROL_AF_MODE_OFF;
5750 }
5751 settings.update(ANDROID_CONTROL_AF_MODE, &focusMode, 1);
5752
5753 if (gCamCapability[mCameraId]->optical_stab_modes_count == 1 &&
5754 gCamCapability[mCameraId]->optical_stab_modes[0] == CAM_OPT_STAB_ON)
5755 optStabMode = ANDROID_LENS_OPTICAL_STABILIZATION_MODE_ON;
5756 else if ((gCamCapability[mCameraId]->optical_stab_modes_count == 1 &&
5757 gCamCapability[mCameraId]->optical_stab_modes[0] == CAM_OPT_STAB_OFF)
5758 || ois_disable)
5759 optStabMode = ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF;
5760 settings.update(ANDROID_LENS_OPTICAL_STABILIZATION_MODE, &optStabMode, 1);
5761
5762 settings.update(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION,
5763 &gCamCapability[mCameraId]->exposure_compensation_default, 1);
5764
5765 static const uint8_t aeLock = ANDROID_CONTROL_AE_LOCK_OFF;
5766 settings.update(ANDROID_CONTROL_AE_LOCK, &aeLock, 1);
5767
5768 static const uint8_t awbLock = ANDROID_CONTROL_AWB_LOCK_OFF;
5769 settings.update(ANDROID_CONTROL_AWB_LOCK, &awbLock, 1);
5770
5771 static const uint8_t awbMode = ANDROID_CONTROL_AWB_MODE_AUTO;
5772 settings.update(ANDROID_CONTROL_AWB_MODE, &awbMode, 1);
5773
5774 static const uint8_t controlMode = ANDROID_CONTROL_MODE_AUTO;
5775 settings.update(ANDROID_CONTROL_MODE, &controlMode, 1);
5776
5777 static const uint8_t effectMode = ANDROID_CONTROL_EFFECT_MODE_OFF;
5778 settings.update(ANDROID_CONTROL_EFFECT_MODE, &effectMode, 1);
5779
5780 static const uint8_t sceneMode = ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY;
5781 settings.update(ANDROID_CONTROL_SCENE_MODE, &sceneMode, 1);
5782
5783 static const uint8_t aeMode = ANDROID_CONTROL_AE_MODE_ON;
5784 settings.update(ANDROID_CONTROL_AE_MODE, &aeMode, 1);
5785
5786 /*flash*/
5787 static const uint8_t flashMode = ANDROID_FLASH_MODE_OFF;
5788 settings.update(ANDROID_FLASH_MODE, &flashMode, 1);
5789
5790 static const uint8_t flashFiringLevel = CAM_FLASH_FIRING_LEVEL_4;
5791 settings.update(ANDROID_FLASH_FIRING_POWER,
5792 &flashFiringLevel, 1);
5793
5794 /* lens */
5795 float default_aperture = gCamCapability[mCameraId]->apertures[0];
5796 settings.update(ANDROID_LENS_APERTURE, &default_aperture, 1);
5797
5798 if (gCamCapability[mCameraId]->filter_densities_count) {
5799 float default_filter_density = gCamCapability[mCameraId]->filter_densities[0];
5800 settings.update(ANDROID_LENS_FILTER_DENSITY, &default_filter_density,
5801 gCamCapability[mCameraId]->filter_densities_count);
5802 }
5803
5804 float default_focal_length = gCamCapability[mCameraId]->focal_length;
5805 settings.update(ANDROID_LENS_FOCAL_LENGTH, &default_focal_length, 1);
5806
5807 float default_focus_distance = 0;
5808 settings.update(ANDROID_LENS_FOCUS_DISTANCE, &default_focus_distance, 1);
5809
5810 static const uint8_t demosaicMode = ANDROID_DEMOSAIC_MODE_FAST;
5811 settings.update(ANDROID_DEMOSAIC_MODE, &demosaicMode, 1);
5812
5813 static const uint8_t hotpixelMode = ANDROID_HOT_PIXEL_MODE_FAST;
5814 settings.update(ANDROID_HOT_PIXEL_MODE, &hotpixelMode, 1);
5815
5816 static const int32_t testpatternMode = ANDROID_SENSOR_TEST_PATTERN_MODE_OFF;
5817 settings.update(ANDROID_SENSOR_TEST_PATTERN_MODE, &testpatternMode, 1);
5818
5819 static const uint8_t faceDetectMode = ANDROID_STATISTICS_FACE_DETECT_MODE_FULL;
5820 settings.update(ANDROID_STATISTICS_FACE_DETECT_MODE, &faceDetectMode, 1);
5821
5822 static const uint8_t histogramMode = ANDROID_STATISTICS_HISTOGRAM_MODE_OFF;
5823 settings.update(ANDROID_STATISTICS_HISTOGRAM_MODE, &histogramMode, 1);
5824
5825 static const uint8_t sharpnessMapMode = ANDROID_STATISTICS_SHARPNESS_MAP_MODE_OFF;
5826 settings.update(ANDROID_STATISTICS_SHARPNESS_MAP_MODE, &sharpnessMapMode, 1);
5827
5828 static const uint8_t hotPixelMapMode = ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE_OFF;
5829 settings.update(ANDROID_STATISTICS_HOT_PIXEL_MAP_MODE, &hotPixelMapMode, 1);
5830
5831 static const uint8_t blackLevelLock = ANDROID_BLACK_LEVEL_LOCK_OFF;
5832 settings.update(ANDROID_BLACK_LEVEL_LOCK, &blackLevelLock, 1);
5833
5834 /* Exposure time(Update the Min Exposure Time)*/
5835 int64_t default_exposure_time = gCamCapability[mCameraId]->exposure_time_range[0];
5836 settings.update(ANDROID_SENSOR_EXPOSURE_TIME, &default_exposure_time, 1);
5837
5838 /* frame duration */
5839 static const int64_t default_frame_duration = NSEC_PER_33MSEC;
5840 settings.update(ANDROID_SENSOR_FRAME_DURATION, &default_frame_duration, 1);
5841
5842 /* sensitivity */
5843 static const int32_t default_sensitivity = 100;
5844 settings.update(ANDROID_SENSOR_SENSITIVITY, &default_sensitivity, 1);
5845
5846 /*edge mode*/
5847 settings.update(ANDROID_EDGE_MODE, &edge_mode, 1);
5848
5849 /*noise reduction mode*/
5850 settings.update(ANDROID_NOISE_REDUCTION_MODE, &noise_red_mode, 1);
5851
5852 /*color correction mode*/
5853 static const uint8_t color_correct_mode = ANDROID_COLOR_CORRECTION_MODE_FAST;
5854 settings.update(ANDROID_COLOR_CORRECTION_MODE, &color_correct_mode, 1);
5855
5856 /*transform matrix mode*/
5857 settings.update(ANDROID_TONEMAP_MODE, &tonemap_mode, 1);
5858
5859 uint8_t edge_strength = (uint8_t)gCamCapability[mCameraId]->sharpness_ctrl.def_value;
5860 settings.update(ANDROID_EDGE_STRENGTH, &edge_strength, 1);
5861
5862 int32_t scaler_crop_region[4];
5863 scaler_crop_region[0] = 0;
5864 scaler_crop_region[1] = 0;
5865 scaler_crop_region[2] = gCamCapability[mCameraId]->active_array_size.width;
5866 scaler_crop_region[3] = gCamCapability[mCameraId]->active_array_size.height;
5867 settings.update(ANDROID_SCALER_CROP_REGION, scaler_crop_region, 4);
5868
5869 static const uint8_t antibanding_mode = ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO;
5870 settings.update(ANDROID_CONTROL_AE_ANTIBANDING_MODE, &antibanding_mode, 1);
5871
5872 /*focus distance*/
5873 float focus_distance = 0.0;
5874 settings.update(ANDROID_LENS_FOCUS_DISTANCE, &focus_distance, 1);
5875
5876 /*target fps range: use maximum range for picture, and maximum fixed range for video*/
5877 float max_range = 0.0;
5878 float max_fixed_fps = 0.0;
5879 int32_t fps_range[2] = {0, 0};
5880 for (uint32_t i = 0; i < gCamCapability[mCameraId]->fps_ranges_tbl_cnt;
5881 i++) {
5882 float range = gCamCapability[mCameraId]->fps_ranges_tbl[i].max_fps -
5883 gCamCapability[mCameraId]->fps_ranges_tbl[i].min_fps;
5884 if (type == CAMERA3_TEMPLATE_PREVIEW ||
5885 type == CAMERA3_TEMPLATE_STILL_CAPTURE ||
5886 type == CAMERA3_TEMPLATE_ZERO_SHUTTER_LAG) {
5887 if (range > max_range) {
5888 fps_range[0] =
5889 (int32_t)gCamCapability[mCameraId]->fps_ranges_tbl[i].min_fps;
5890 fps_range[1] =
5891 (int32_t)gCamCapability[mCameraId]->fps_ranges_tbl[i].max_fps;
5892 max_range = range;
5893 }
5894 } else {
5895 if (range < 0.01 && max_fixed_fps <
5896 gCamCapability[mCameraId]->fps_ranges_tbl[i].max_fps) {
5897 fps_range[0] =
5898 (int32_t)gCamCapability[mCameraId]->fps_ranges_tbl[i].min_fps;
5899 fps_range[1] =
5900 (int32_t)gCamCapability[mCameraId]->fps_ranges_tbl[i].max_fps;
5901 max_fixed_fps = gCamCapability[mCameraId]->fps_ranges_tbl[i].max_fps;
5902 }
5903 }
5904 }
5905 settings.update(ANDROID_CONTROL_AE_TARGET_FPS_RANGE, fps_range, 2);
5906
5907 /*precapture trigger*/
5908 uint8_t precapture_trigger = ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER_IDLE;
5909 settings.update(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER, &precapture_trigger, 1);
5910
5911 /*af trigger*/
5912 uint8_t af_trigger = ANDROID_CONTROL_AF_TRIGGER_IDLE;
5913 settings.update(ANDROID_CONTROL_AF_TRIGGER, &af_trigger, 1);
5914
5915 /* ae & af regions */
5916 int32_t active_region[] = {
5917 gCamCapability[mCameraId]->active_array_size.left,
5918 gCamCapability[mCameraId]->active_array_size.top,
5919 gCamCapability[mCameraId]->active_array_size.left +
5920 gCamCapability[mCameraId]->active_array_size.width,
5921 gCamCapability[mCameraId]->active_array_size.top +
5922 gCamCapability[mCameraId]->active_array_size.height,
5923 0};
5924 settings.update(ANDROID_CONTROL_AE_REGIONS, active_region, 5);
5925 settings.update(ANDROID_CONTROL_AF_REGIONS, active_region, 5);
5926
5927 /* black level lock */
5928 uint8_t blacklevel_lock = ANDROID_BLACK_LEVEL_LOCK_OFF;
5929 settings.update(ANDROID_BLACK_LEVEL_LOCK, &blacklevel_lock, 1);
5930
5931 /* face detect mode */
5932 uint8_t facedetect_mode = ANDROID_STATISTICS_FACE_DETECT_MODE_OFF;
5933 settings.update(ANDROID_STATISTICS_FACE_DETECT_MODE, &facedetect_mode, 1);
5934
5935 /* lens shading map mode */
5936 uint8_t shadingmap_mode = ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_OFF;
5937 if (CAM_SENSOR_RAW == gCamCapability[mCameraId]->sensor_type.sens_type &&
5938 gCamCapability[mCameraId]->supported_raw_dim_cnt > 0) {
5939 shadingmap_mode = ANDROID_STATISTICS_LENS_SHADING_MAP_MODE_ON;
5940 }
5941 settings.update(ANDROID_STATISTICS_LENS_SHADING_MAP_MODE, &shadingmap_mode, 1);
5942
5943 //special defaults for manual template
5944 if (type == CAMERA3_TEMPLATE_MANUAL) {
5945 static const uint8_t manualControlMode = ANDROID_CONTROL_MODE_OFF;
5946 settings.update(ANDROID_CONTROL_MODE, &manualControlMode, 1);
5947
5948 static const uint8_t manualFocusMode = ANDROID_CONTROL_AF_MODE_OFF;
5949 settings.update(ANDROID_CONTROL_AF_MODE, &manualFocusMode, 1);
5950
5951 static const uint8_t manualAeMode = ANDROID_CONTROL_AE_MODE_OFF;
5952 settings.update(ANDROID_CONTROL_AE_MODE, &manualAeMode, 1);
5953
5954 static const uint8_t manualAwbMode = ANDROID_CONTROL_AWB_MODE_OFF;
5955 settings.update(ANDROID_CONTROL_AWB_MODE, &manualAwbMode, 1);
5956
5957 static const uint8_t manualTonemapMode = ANDROID_TONEMAP_MODE_FAST;
5958 settings.update(ANDROID_TONEMAP_MODE, &manualTonemapMode, 1);
5959
5960 static const uint8_t manualColorCorrectMode = ANDROID_COLOR_CORRECTION_MODE_TRANSFORM_MATRIX;
5961 settings.update(ANDROID_COLOR_CORRECTION_MODE, &manualColorCorrectMode, 1);
5962 }
5963
5964 /* CDS default */
5965 char prop[PROPERTY_VALUE_MAX];
5966 memset(prop, 0, sizeof(prop));
5967 property_get("persist.camera.CDS", prop, "Auto");
5968 cam_cds_mode_type_t cds_mode = CAM_CDS_MODE_AUTO;
5969 cds_mode = lookupProp(CDS_MAP, sizeof(CDS_MAP)/sizeof(QCameraPropMap), prop);
5970 if (CAM_CDS_MODE_MAX == cds_mode) {
5971 cds_mode = CAM_CDS_MODE_AUTO;
5972 }
5973 int32_t mode = cds_mode;
5974 settings.update(QCAMERA3_CDS_MODE, &mode, 1);
5975
5976 mDefaultMetadata[type] = settings.release();
5977
5978 pthread_mutex_unlock(&mMutex);
5979 return mDefaultMetadata[type];
5980 }
5981
5982 /*===========================================================================
5983 * FUNCTION : setFrameParameters
5984 *
5985 * DESCRIPTION: set parameters per frame as requested in the metadata from
5986 * framework
5987 *
5988 * PARAMETERS :
5989 * @request : request that needs to be serviced
5990 * @streamID : Stream ID of all the requested streams
5991 * @blob_request: Whether this request is a blob request or not
5992 *
5993 * RETURN : success: NO_ERROR
5994 * failure:
5995 *==========================================================================*/
setFrameParameters(camera3_capture_request_t * request,cam_stream_ID_t streamID,int blob_request,uint32_t snapshotStreamId)5996 int QCamera3HardwareInterface::setFrameParameters(
5997 camera3_capture_request_t *request,
5998 cam_stream_ID_t streamID,
5999 int blob_request,
6000 uint32_t snapshotStreamId)
6001 {
6002 /*translate from camera_metadata_t type to parm_type_t*/
6003 int rc = 0;
6004 int32_t hal_version = CAM_HAL_V3;
6005
6006 memset(mParameters, 0, sizeof(parm_buffer_t));
6007 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_HAL_VERSION,
6008 sizeof(hal_version), &hal_version);
6009 if (rc < 0) {
6010 ALOGE("%s: Failed to set hal version in the parameters", __func__);
6011 return BAD_VALUE;
6012 }
6013
6014 /*we need to update the frame number in the parameters*/
6015 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_FRAME_NUMBER,
6016 sizeof(request->frame_number), &(request->frame_number));
6017 if (rc < 0) {
6018 ALOGE("%s: Failed to set the frame number in the parameters", __func__);
6019 return BAD_VALUE;
6020 }
6021
6022 /* Update stream id of all the requested buffers */
6023 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_STREAM_ID,
6024 sizeof(cam_stream_ID_t), &streamID);
6025
6026 if (rc < 0) {
6027 ALOGE("%s: Failed to set stream type mask in the parameters", __func__);
6028 return BAD_VALUE;
6029 }
6030
6031 if(request->settings != NULL){
6032 rc = translateToHalMetadata(request, mParameters, snapshotStreamId);
6033 if (blob_request)
6034 memcpy(mPrevParameters, mParameters, sizeof(metadata_buffer_t));
6035 }
6036
6037 return rc;
6038 }
6039
6040 /*===========================================================================
6041 * FUNCTION : setReprocParameters
6042 *
6043 * DESCRIPTION: Translate frameworks metadata to HAL metadata structure, and
6044 * return it.
6045 *
6046 * PARAMETERS :
6047 * @request : request that needs to be serviced
6048 *
6049 * RETURN : success: NO_ERROR
6050 * failure:
6051 *==========================================================================*/
setReprocParameters(camera3_capture_request_t * request,metadata_buffer_t * reprocParam,uint32_t snapshotStreamId)6052 int32_t QCamera3HardwareInterface::setReprocParameters(
6053 camera3_capture_request_t *request, metadata_buffer_t *reprocParam,
6054 uint32_t snapshotStreamId)
6055 {
6056 /*translate from camera_metadata_t type to parm_type_t*/
6057 int rc = 0;
6058
6059 if (NULL == request->settings){
6060 ALOGE("%s: Reprocess settings cannot be NULL", __func__);
6061 return BAD_VALUE;
6062 }
6063
6064 if (NULL == reprocParam) {
6065 ALOGE("%s: Invalid reprocessing metadata buffer", __func__);
6066 return BAD_VALUE;
6067 }
6068 memset(reprocParam, 0, sizeof(metadata_buffer_t));
6069
6070 /*we need to update the frame number in the parameters*/
6071 rc = AddSetParmEntryToBatch(reprocParam, CAM_INTF_META_FRAME_NUMBER,
6072 sizeof(request->frame_number), &(request->frame_number));
6073 if (rc < 0) {
6074 ALOGE("%s: Failed to set the frame number in the parameters", __func__);
6075 return rc;
6076 }
6077
6078 rc = translateToHalMetadata(request, reprocParam, snapshotStreamId);
6079 if (rc < 0) {
6080 ALOGE("%s: Failed to translate reproc request", __func__);
6081 return rc;
6082 }
6083
6084 CameraMetadata frame_settings;
6085 frame_settings = request->settings;
6086 if (frame_settings.exists(QCAMERA3_CROP_COUNT_REPROCESS) &&
6087 frame_settings.exists(QCAMERA3_CROP_REPROCESS) &&
6088 frame_settings.exists(QCAMERA3_CROP_STREAM_ID_REPROCESS)) {
6089 int32_t *crop_count =
6090 frame_settings.find(QCAMERA3_CROP_COUNT_REPROCESS).data.i32;
6091 int32_t *crop_data =
6092 frame_settings.find(QCAMERA3_CROP_REPROCESS).data.i32;
6093 int32_t *crop_stream_ids =
6094 frame_settings.find(QCAMERA3_CROP_STREAM_ID_REPROCESS).data.i32;
6095 if ((0 < *crop_count) && (*crop_count < MAX_NUM_STREAMS)) {
6096 bool found = false;
6097 int32_t i;
6098 for (i = 0; i < *crop_count; i++) {
6099 if (crop_stream_ids[i] == (int32_t) request->input_buffer->stream) {
6100 found = true;
6101 break;
6102 }
6103 }
6104
6105 if (found) {
6106 cam_crop_data_t crop_meta;
6107 memset(&crop_meta, 0, sizeof(cam_crop_data_t));
6108 crop_meta.num_of_streams = 1;
6109 crop_meta.crop_info[0].crop.left = crop_data[i*4];
6110 crop_meta.crop_info[0].crop.top = crop_data[i*4 + 1];
6111 crop_meta.crop_info[0].crop.width = crop_data[i*4 + 2];
6112 crop_meta.crop_info[0].crop.height = crop_data[i*4 + 3];
6113 rc = AddSetParmEntryToBatch(reprocParam,
6114 CAM_INTF_META_CROP_DATA,
6115 sizeof(cam_crop_data_t), &crop_meta);
6116 CDBG("%s: Found reprocess crop data for stream %p %dx%d, %dx%d",
6117 __func__,
6118 request->input_buffer->stream,
6119 crop_meta.crop_info[0].crop.left,
6120 crop_meta.crop_info[0].crop.top,
6121 crop_meta.crop_info[0].crop.width,
6122 crop_meta.crop_info[0].crop.height);
6123 } else {
6124 ALOGE("%s: No matching reprocess input stream found!", __func__);
6125 }
6126 } else {
6127 ALOGE("%s: Invalid reprocess crop count %d!", __func__, *crop_count);
6128 }
6129 }
6130
6131 return rc;
6132 }
6133
6134 /*===========================================================================
6135 * FUNCTION : translateToHalMetadata
6136 *
6137 * DESCRIPTION: read from the camera_metadata_t and change to parm_type_t
6138 *
6139 *
6140 * PARAMETERS :
6141 * @request : request sent from framework
6142 *
6143 *
6144 * RETURN : success: NO_ERROR
6145 * failure:
6146 *==========================================================================*/
translateToHalMetadata(const camera3_capture_request_t * request,metadata_buffer_t * hal_metadata,uint32_t snapshotStreamId)6147 int QCamera3HardwareInterface::translateToHalMetadata
6148 (const camera3_capture_request_t *request,
6149 metadata_buffer_t *hal_metadata,
6150 uint32_t snapshotStreamId)
6151 {
6152 int rc = 0;
6153 CameraMetadata frame_settings;
6154 frame_settings = request->settings;
6155
6156 /* Do not change the order of the following list unless you know what you are
6157 * doing.
6158 * The order is laid out in such a way that parameters in the front of the table
6159 * may be used to override the parameters later in the table. Examples are:
6160 * 1. META_MODE should precede AEC/AWB/AF MODE
6161 * 2. AEC MODE should preced EXPOSURE_TIME/SENSITIVITY/FRAME_DURATION
6162 * 3. AWB_MODE should precede COLOR_CORRECTION_MODE
6163 * 4. Any mode should precede it's corresponding settings
6164 */
6165 if (frame_settings.exists(ANDROID_CONTROL_MODE)) {
6166 uint8_t metaMode = frame_settings.find(ANDROID_CONTROL_MODE).data.u8[0];
6167 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_META_MODE,
6168 sizeof(metaMode), &metaMode);
6169 if (metaMode == ANDROID_CONTROL_MODE_USE_SCENE_MODE) {
6170 camera_metadata_entry entry = frame_settings.find(ANDROID_CONTROL_SCENE_MODE);
6171 if (0 < entry.count) {
6172 uint8_t fwk_sceneMode = entry.data.u8[0];
6173 uint8_t sceneMode = lookupHalName(SCENE_MODES_MAP,
6174 sizeof(SCENE_MODES_MAP)/sizeof(SCENE_MODES_MAP[0]),
6175 fwk_sceneMode);
6176 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_PARM_BESTSHOT_MODE,
6177 sizeof(sceneMode), &sceneMode);
6178 }
6179 } else if (metaMode == ANDROID_CONTROL_MODE_OFF) {
6180 uint8_t sceneMode = CAM_SCENE_MODE_OFF;
6181 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_PARM_BESTSHOT_MODE,
6182 sizeof(sceneMode), &sceneMode);
6183 } else if (metaMode == ANDROID_CONTROL_MODE_AUTO) {
6184 uint8_t sceneMode = CAM_SCENE_MODE_OFF;
6185 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_PARM_BESTSHOT_MODE,
6186 sizeof(sceneMode), &sceneMode);
6187 }
6188 }
6189
6190 if (frame_settings.exists(ANDROID_CONTROL_AE_MODE)) {
6191 uint8_t fwk_aeMode =
6192 frame_settings.find(ANDROID_CONTROL_AE_MODE).data.u8[0];
6193 uint8_t aeMode;
6194 int32_t redeye;
6195
6196 if (fwk_aeMode == ANDROID_CONTROL_AE_MODE_OFF ) {
6197 aeMode = CAM_AE_MODE_OFF;
6198 } else {
6199 aeMode = CAM_AE_MODE_ON;
6200 }
6201 if (fwk_aeMode == ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE) {
6202 redeye = 1;
6203 } else {
6204 redeye = 0;
6205 }
6206
6207 int32_t flashMode = (int32_t)lookupHalName(AE_FLASH_MODE_MAP,
6208 sizeof(AE_FLASH_MODE_MAP),
6209 fwk_aeMode);
6210 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_META_AEC_MODE,
6211 sizeof(aeMode), &aeMode);
6212 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_PARM_LED_MODE,
6213 sizeof(flashMode), &flashMode);
6214 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_PARM_REDEYE_REDUCTION,
6215 sizeof(redeye), &redeye);
6216 }
6217
6218 if (frame_settings.exists(ANDROID_CONTROL_AWB_MODE)) {
6219 uint8_t fwk_whiteLevel =
6220 frame_settings.find(ANDROID_CONTROL_AWB_MODE).data.u8[0];
6221 uint8_t whiteLevel = lookupHalName(WHITE_BALANCE_MODES_MAP,
6222 sizeof(WHITE_BALANCE_MODES_MAP),
6223 fwk_whiteLevel);
6224 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_PARM_WHITE_BALANCE,
6225 sizeof(whiteLevel), &whiteLevel);
6226 }
6227
6228 if (frame_settings.exists(ANDROID_COLOR_CORRECTION_ABERRATION_MODE)) {
6229 uint8_t fwk_cacMode =
6230 frame_settings.find(
6231 ANDROID_COLOR_CORRECTION_ABERRATION_MODE).data.u8[0];
6232 int8_t val = lookupHalName(COLOR_ABERRATION_MAP,
6233 sizeof(COLOR_ABERRATION_MAP)/sizeof(COLOR_ABERRATION_MAP[0]),
6234 fwk_cacMode);
6235 if (NAME_NOT_FOUND != val) {
6236 cam_aberration_mode_t cacMode = (cam_aberration_mode_t) val;
6237 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_PARM_CAC,
6238 sizeof(cacMode), &cacMode);
6239 } else {
6240 ALOGE("%s: Invalid framework CAC mode: %d", __func__, fwk_cacMode);
6241 }
6242 }
6243
6244 if (frame_settings.exists(ANDROID_CONTROL_AF_MODE)) {
6245 uint8_t fwk_focusMode =
6246 frame_settings.find(ANDROID_CONTROL_AF_MODE).data.u8[0];
6247 uint8_t focusMode;
6248 focusMode = lookupHalName(FOCUS_MODES_MAP,
6249 sizeof(FOCUS_MODES_MAP),
6250 fwk_focusMode);
6251 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_PARM_FOCUS_MODE,
6252 sizeof(focusMode), &focusMode);
6253 }
6254
6255 if (frame_settings.exists(ANDROID_LENS_FOCUS_DISTANCE)) {
6256 float focalDistance = frame_settings.find(ANDROID_LENS_FOCUS_DISTANCE).data.f[0];
6257 rc = AddSetParmEntryToBatch(hal_metadata,
6258 CAM_INTF_META_LENS_FOCUS_DISTANCE,
6259 sizeof(focalDistance), &focalDistance);
6260 }
6261
6262 if (frame_settings.exists(ANDROID_CONTROL_AE_ANTIBANDING_MODE)) {
6263 uint8_t fwk_antibandingMode =
6264 frame_settings.find(ANDROID_CONTROL_AE_ANTIBANDING_MODE).data.u8[0];
6265 int32_t hal_antibandingMode = lookupHalName(ANTIBANDING_MODES_MAP,
6266 sizeof(ANTIBANDING_MODES_MAP)/sizeof(ANTIBANDING_MODES_MAP[0]),
6267 fwk_antibandingMode);
6268 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_PARM_ANTIBANDING,
6269 sizeof(hal_antibandingMode), &hal_antibandingMode);
6270 }
6271
6272 if (frame_settings.exists(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION)) {
6273 int32_t expCompensation = frame_settings.find(
6274 ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION).data.i32[0];
6275 if (expCompensation < gCamCapability[mCameraId]->exposure_compensation_min)
6276 expCompensation = gCamCapability[mCameraId]->exposure_compensation_min;
6277 if (expCompensation > gCamCapability[mCameraId]->exposure_compensation_max)
6278 expCompensation = gCamCapability[mCameraId]->exposure_compensation_max;
6279 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_PARM_EXPOSURE_COMPENSATION,
6280 sizeof(expCompensation), &expCompensation);
6281 }
6282
6283 if (frame_settings.exists(ANDROID_CONTROL_AE_LOCK)) {
6284 uint8_t aeLock = frame_settings.find(ANDROID_CONTROL_AE_LOCK).data.u8[0];
6285 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_PARM_AEC_LOCK,
6286 sizeof(aeLock), &aeLock);
6287 }
6288 if (frame_settings.exists(ANDROID_CONTROL_AE_TARGET_FPS_RANGE)) {
6289 cam_fps_range_t fps_range;
6290 fps_range.min_fps =
6291 frame_settings.find(ANDROID_CONTROL_AE_TARGET_FPS_RANGE).data.i32[0];
6292 fps_range.max_fps =
6293 frame_settings.find(ANDROID_CONTROL_AE_TARGET_FPS_RANGE).data.i32[1];
6294 fps_range.video_min_fps = fps_range.min_fps;
6295 fps_range.video_max_fps = fps_range.max_fps;
6296 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_PARM_FPS_RANGE,
6297 sizeof(fps_range), &fps_range);
6298 }
6299
6300 if (frame_settings.exists(ANDROID_CONTROL_AWB_LOCK)) {
6301 uint8_t awbLock =
6302 frame_settings.find(ANDROID_CONTROL_AWB_LOCK).data.u8[0];
6303 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_PARM_AWB_LOCK,
6304 sizeof(awbLock), &awbLock);
6305 }
6306
6307 if (frame_settings.exists(ANDROID_CONTROL_EFFECT_MODE)) {
6308 uint8_t fwk_effectMode =
6309 frame_settings.find(ANDROID_CONTROL_EFFECT_MODE).data.u8[0];
6310 uint8_t effectMode = lookupHalName(EFFECT_MODES_MAP,
6311 sizeof(EFFECT_MODES_MAP),
6312 fwk_effectMode);
6313 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_PARM_EFFECT,
6314 sizeof(effectMode), &effectMode);
6315 }
6316
6317 if (frame_settings.exists(ANDROID_COLOR_CORRECTION_MODE)) {
6318 uint8_t colorCorrectMode =
6319 frame_settings.find(ANDROID_COLOR_CORRECTION_MODE).data.u8[0];
6320 rc =
6321 AddSetParmEntryToBatch(hal_metadata, CAM_INTF_META_COLOR_CORRECT_MODE,
6322 sizeof(colorCorrectMode), &colorCorrectMode);
6323 }
6324
6325 if (frame_settings.exists(ANDROID_COLOR_CORRECTION_GAINS)) {
6326 cam_color_correct_gains_t colorCorrectGains;
6327 for (int i = 0; i < 4; i++) {
6328 colorCorrectGains.gains[i] =
6329 frame_settings.find(ANDROID_COLOR_CORRECTION_GAINS).data.f[i];
6330 }
6331 rc =
6332 AddSetParmEntryToBatch(hal_metadata, CAM_INTF_META_COLOR_CORRECT_GAINS,
6333 sizeof(colorCorrectGains), &colorCorrectGains);
6334 }
6335
6336 if (frame_settings.exists(ANDROID_COLOR_CORRECTION_TRANSFORM)) {
6337 cam_color_correct_matrix_t colorCorrectTransform;
6338 cam_rational_type_t transform_elem;
6339 int num = 0;
6340 for (int i = 0; i < 3; i++) {
6341 for (int j = 0; j < 3; j++) {
6342 transform_elem.numerator =
6343 frame_settings.find(ANDROID_COLOR_CORRECTION_TRANSFORM).data.r[num].numerator;
6344 transform_elem.denominator =
6345 frame_settings.find(ANDROID_COLOR_CORRECTION_TRANSFORM).data.r[num].denominator;
6346 colorCorrectTransform.transform_matrix[i][j] = transform_elem;
6347 num++;
6348 }
6349 }
6350 rc =
6351 AddSetParmEntryToBatch(hal_metadata, CAM_INTF_META_COLOR_CORRECT_TRANSFORM,
6352 sizeof(colorCorrectTransform), &colorCorrectTransform);
6353 }
6354
6355 cam_trigger_t aecTrigger;
6356 aecTrigger.trigger = CAM_AEC_TRIGGER_IDLE;
6357 aecTrigger.trigger_id = -1;
6358 if (frame_settings.exists(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER)&&
6359 frame_settings.exists(ANDROID_CONTROL_AE_PRECAPTURE_ID)) {
6360 aecTrigger.trigger =
6361 frame_settings.find(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER).data.u8[0];
6362 aecTrigger.trigger_id =
6363 frame_settings.find(ANDROID_CONTROL_AE_PRECAPTURE_ID).data.i32[0];
6364 rc = AddSetParmEntryToBatch(hal_metadata,
6365 CAM_INTF_META_AEC_PRECAPTURE_TRIGGER,
6366 sizeof(aecTrigger), &aecTrigger);
6367 }
6368 /*af_trigger must come with a trigger id*/
6369 if (frame_settings.exists(ANDROID_CONTROL_AF_TRIGGER) &&
6370 frame_settings.exists(ANDROID_CONTROL_AF_TRIGGER_ID)) {
6371 cam_trigger_t af_trigger;
6372 af_trigger.trigger =
6373 frame_settings.find(ANDROID_CONTROL_AF_TRIGGER).data.u8[0];
6374 af_trigger.trigger_id =
6375 frame_settings.find(ANDROID_CONTROL_AF_TRIGGER_ID).data.i32[0];
6376 rc = AddSetParmEntryToBatch(hal_metadata,
6377 CAM_INTF_META_AF_TRIGGER, sizeof(af_trigger), &af_trigger);
6378 }
6379
6380 if (frame_settings.exists(ANDROID_DEMOSAIC_MODE)) {
6381 int32_t demosaic =
6382 frame_settings.find(ANDROID_DEMOSAIC_MODE).data.u8[0];
6383 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_META_DEMOSAIC,
6384 sizeof(demosaic), &demosaic);
6385 }
6386
6387 if (frame_settings.exists(ANDROID_EDGE_MODE)) {
6388 cam_edge_application_t edge_application;
6389 edge_application.edge_mode = frame_settings.find(ANDROID_EDGE_MODE).data.u8[0];
6390 if (edge_application.edge_mode == CAM_EDGE_MODE_OFF) {
6391 edge_application.sharpness = 0;
6392 } else {
6393 if (frame_settings.exists(ANDROID_EDGE_STRENGTH)) {
6394 uint8_t edgeStrength =
6395 frame_settings.find(ANDROID_EDGE_STRENGTH).data.u8[0];
6396 edge_application.sharpness = (int32_t)edgeStrength;
6397 } else {
6398 edge_application.sharpness = gCamCapability[mCameraId]->sharpness_ctrl.def_value; //default
6399 }
6400 }
6401 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_META_EDGE_MODE,
6402 sizeof(edge_application), &edge_application);
6403 }
6404
6405 if (frame_settings.exists(ANDROID_FLASH_MODE)) {
6406 int32_t respectFlashMode = 1;
6407 if (frame_settings.exists(ANDROID_CONTROL_AE_MODE)) {
6408 uint8_t fwk_aeMode =
6409 frame_settings.find(ANDROID_CONTROL_AE_MODE).data.u8[0];
6410 if (fwk_aeMode > ANDROID_CONTROL_AE_MODE_ON) {
6411 respectFlashMode = 0;
6412 CDBG_HIGH("%s: AE Mode controls flash, ignore android.flash.mode",
6413 __func__);
6414 }
6415 }
6416 if (respectFlashMode) {
6417 uint8_t flashMode =
6418 frame_settings.find(ANDROID_FLASH_MODE).data.u8[0];
6419 flashMode = (int32_t)lookupHalName(FLASH_MODES_MAP,
6420 sizeof(FLASH_MODES_MAP),
6421 flashMode);
6422 CDBG_HIGH("%s: flash mode after mapping %d", __func__, flashMode);
6423 // To check: CAM_INTF_META_FLASH_MODE usage
6424 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_PARM_LED_MODE,
6425 sizeof(flashMode), &flashMode);
6426 }
6427 }
6428
6429 if (frame_settings.exists(ANDROID_FLASH_FIRING_POWER)) {
6430 uint8_t flashPower =
6431 frame_settings.find(ANDROID_FLASH_FIRING_POWER).data.u8[0];
6432 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_META_FLASH_POWER,
6433 sizeof(flashPower), &flashPower);
6434 }
6435
6436 if (frame_settings.exists(ANDROID_FLASH_FIRING_TIME)) {
6437 int64_t flashFiringTime =
6438 frame_settings.find(ANDROID_FLASH_FIRING_TIME).data.i64[0];
6439 rc = AddSetParmEntryToBatch(hal_metadata,
6440 CAM_INTF_META_FLASH_FIRING_TIME, sizeof(flashFiringTime), &flashFiringTime);
6441 }
6442
6443 if (frame_settings.exists(ANDROID_HOT_PIXEL_MODE)) {
6444 uint8_t hotPixelMode =
6445 frame_settings.find(ANDROID_HOT_PIXEL_MODE).data.u8[0];
6446 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_META_HOTPIXEL_MODE,
6447 sizeof(hotPixelMode), &hotPixelMode);
6448 }
6449
6450 if (frame_settings.exists(ANDROID_LENS_APERTURE)) {
6451 float lensAperture =
6452 frame_settings.find( ANDROID_LENS_APERTURE).data.f[0];
6453 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_META_LENS_APERTURE,
6454 sizeof(lensAperture), &lensAperture);
6455 }
6456
6457 if (frame_settings.exists(ANDROID_LENS_FILTER_DENSITY)) {
6458 float filterDensity =
6459 frame_settings.find(ANDROID_LENS_FILTER_DENSITY).data.f[0];
6460 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_META_LENS_FILTERDENSITY,
6461 sizeof(filterDensity), &filterDensity);
6462 }
6463
6464 if (frame_settings.exists(ANDROID_LENS_FOCAL_LENGTH)) {
6465 float focalLength =
6466 frame_settings.find(ANDROID_LENS_FOCAL_LENGTH).data.f[0];
6467 rc = AddSetParmEntryToBatch(hal_metadata,
6468 CAM_INTF_META_LENS_FOCAL_LENGTH,
6469 sizeof(focalLength), &focalLength);
6470 }
6471
6472 if (frame_settings.exists(ANDROID_LENS_OPTICAL_STABILIZATION_MODE)) {
6473 uint8_t optStabMode =
6474 frame_settings.find(ANDROID_LENS_OPTICAL_STABILIZATION_MODE).data.u8[0];
6475 rc = AddSetParmEntryToBatch(hal_metadata,
6476 CAM_INTF_META_LENS_OPT_STAB_MODE,
6477 sizeof(optStabMode), &optStabMode);
6478 }
6479
6480 if (frame_settings.exists(ANDROID_NOISE_REDUCTION_MODE)) {
6481 uint8_t noiseRedMode =
6482 frame_settings.find(ANDROID_NOISE_REDUCTION_MODE).data.u8[0];
6483 rc = AddSetParmEntryToBatch(hal_metadata,
6484 CAM_INTF_META_NOISE_REDUCTION_MODE,
6485 sizeof(noiseRedMode), &noiseRedMode);
6486 }
6487
6488 if (frame_settings.exists(ANDROID_NOISE_REDUCTION_STRENGTH)) {
6489 uint8_t noiseRedStrength =
6490 frame_settings.find(ANDROID_NOISE_REDUCTION_STRENGTH).data.u8[0];
6491 rc = AddSetParmEntryToBatch(hal_metadata,
6492 CAM_INTF_META_NOISE_REDUCTION_STRENGTH,
6493 sizeof(noiseRedStrength), &noiseRedStrength);
6494 }
6495
6496 if (frame_settings.exists(ANDROID_REPROCESS_EFFECTIVE_EXPOSURE_FACTOR)) {
6497 float reprocessEffectiveExposureFactor =
6498 frame_settings.find(ANDROID_REPROCESS_EFFECTIVE_EXPOSURE_FACTOR).data.f[0];
6499 rc = AddSetParmEntryToBatch(hal_metadata,
6500 CAM_INTF_META_EFFECTIVE_EXPOSURE_FACTOR,
6501 sizeof(reprocessEffectiveExposureFactor), &reprocessEffectiveExposureFactor);
6502 }
6503
6504 cam_crop_region_t scalerCropRegion;
6505 bool scalerCropSet = false;
6506 if (frame_settings.exists(ANDROID_SCALER_CROP_REGION)) {
6507 scalerCropRegion.left =
6508 frame_settings.find(ANDROID_SCALER_CROP_REGION).data.i32[0];
6509 scalerCropRegion.top =
6510 frame_settings.find(ANDROID_SCALER_CROP_REGION).data.i32[1];
6511 scalerCropRegion.width =
6512 frame_settings.find(ANDROID_SCALER_CROP_REGION).data.i32[2];
6513 scalerCropRegion.height =
6514 frame_settings.find(ANDROID_SCALER_CROP_REGION).data.i32[3];
6515 rc = AddSetParmEntryToBatch(hal_metadata,
6516 CAM_INTF_META_SCALER_CROP_REGION,
6517 sizeof(scalerCropRegion), &scalerCropRegion);
6518 scalerCropSet = true;
6519 }
6520
6521 if (frame_settings.exists(ANDROID_SENSOR_EXPOSURE_TIME)) {
6522 int64_t sensorExpTime =
6523 frame_settings.find(ANDROID_SENSOR_EXPOSURE_TIME).data.i64[0];
6524 CDBG("%s: setting sensorExpTime %lld", __func__, sensorExpTime);
6525 rc = AddSetParmEntryToBatch(hal_metadata,
6526 CAM_INTF_META_SENSOR_EXPOSURE_TIME,
6527 sizeof(sensorExpTime), &sensorExpTime);
6528 }
6529
6530 if (frame_settings.exists(ANDROID_SENSOR_FRAME_DURATION)) {
6531 int64_t sensorFrameDuration =
6532 frame_settings.find(ANDROID_SENSOR_FRAME_DURATION).data.i64[0];
6533 int64_t minFrameDuration = getMinFrameDuration(request);
6534 sensorFrameDuration = MAX(sensorFrameDuration, minFrameDuration);
6535 if (sensorFrameDuration > gCamCapability[mCameraId]->max_frame_duration)
6536 sensorFrameDuration = gCamCapability[mCameraId]->max_frame_duration;
6537 CDBG("%s: clamp sensorFrameDuration to %lld", __func__, sensorFrameDuration);
6538 rc = AddSetParmEntryToBatch(hal_metadata,
6539 CAM_INTF_META_SENSOR_FRAME_DURATION,
6540 sizeof(sensorFrameDuration), &sensorFrameDuration);
6541 }
6542
6543 if (frame_settings.exists(ANDROID_SENSOR_SENSITIVITY)) {
6544 int32_t sensorSensitivity =
6545 frame_settings.find(ANDROID_SENSOR_SENSITIVITY).data.i32[0];
6546 if (sensorSensitivity <
6547 gCamCapability[mCameraId]->sensitivity_range.min_sensitivity)
6548 sensorSensitivity =
6549 gCamCapability[mCameraId]->sensitivity_range.min_sensitivity;
6550 if (sensorSensitivity >
6551 gCamCapability[mCameraId]->sensitivity_range.max_sensitivity)
6552 sensorSensitivity =
6553 gCamCapability[mCameraId]->sensitivity_range.max_sensitivity;
6554 CDBG("%s: clamp sensorSensitivity to %d", __func__, sensorSensitivity);
6555 rc = AddSetParmEntryToBatch(hal_metadata,
6556 CAM_INTF_META_SENSOR_SENSITIVITY,
6557 sizeof(sensorSensitivity), &sensorSensitivity);
6558 }
6559
6560 if (frame_settings.exists(ANDROID_SHADING_MODE)) {
6561 uint8_t shadingMode =
6562 frame_settings.find(ANDROID_SHADING_MODE).data.u8[0];
6563 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_META_SHADING_MODE,
6564 sizeof(shadingMode), &shadingMode);
6565 }
6566
6567 if (frame_settings.exists(ANDROID_SHADING_STRENGTH)) {
6568 uint8_t shadingStrength =
6569 frame_settings.find(ANDROID_SHADING_STRENGTH).data.u8[0];
6570 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_META_SHADING_STRENGTH,
6571 sizeof(shadingStrength), &shadingStrength);
6572 }
6573
6574 if (frame_settings.exists(ANDROID_STATISTICS_FACE_DETECT_MODE)) {
6575 uint8_t fwk_facedetectMode =
6576 frame_settings.find(ANDROID_STATISTICS_FACE_DETECT_MODE).data.u8[0];
6577 uint8_t facedetectMode =
6578 lookupHalName(FACEDETECT_MODES_MAP,
6579 sizeof(FACEDETECT_MODES_MAP), fwk_facedetectMode);
6580 rc = AddSetParmEntryToBatch(hal_metadata,
6581 CAM_INTF_META_STATS_FACEDETECT_MODE,
6582 sizeof(facedetectMode), &facedetectMode);
6583 }
6584
6585 if (frame_settings.exists(ANDROID_STATISTICS_HISTOGRAM_MODE)) {
6586 uint8_t histogramMode =
6587 frame_settings.find(ANDROID_STATISTICS_HISTOGRAM_MODE).data.u8[0];
6588 rc = AddSetParmEntryToBatch(hal_metadata,
6589 CAM_INTF_META_STATS_HISTOGRAM_MODE,
6590 sizeof(histogramMode), &histogramMode);
6591 }
6592
6593 if (frame_settings.exists(ANDROID_STATISTICS_SHARPNESS_MAP_MODE)) {
6594 uint8_t sharpnessMapMode =
6595 frame_settings.find(ANDROID_STATISTICS_SHARPNESS_MAP_MODE).data.u8[0];
6596 rc = AddSetParmEntryToBatch(hal_metadata,
6597 CAM_INTF_META_STATS_SHARPNESS_MAP_MODE,
6598 sizeof(sharpnessMapMode), &sharpnessMapMode);
6599 }
6600
6601 if (frame_settings.exists(ANDROID_TONEMAP_MODE)) {
6602 uint8_t tonemapMode =
6603 frame_settings.find(ANDROID_TONEMAP_MODE).data.u8[0];
6604 rc = AddSetParmEntryToBatch(hal_metadata,
6605 CAM_INTF_META_TONEMAP_MODE,
6606 sizeof(tonemapMode), &tonemapMode);
6607 }
6608 /* Tonemap curve channels ch0 = G, ch 1 = B, ch 2 = R */
6609 /*All tonemap channels will have the same number of points*/
6610 if (frame_settings.exists(ANDROID_TONEMAP_CURVE_GREEN) &&
6611 frame_settings.exists(ANDROID_TONEMAP_CURVE_BLUE) &&
6612 frame_settings.exists(ANDROID_TONEMAP_CURVE_RED)) {
6613 cam_rgb_tonemap_curves tonemapCurves;
6614 tonemapCurves.tonemap_points_cnt = frame_settings.find(ANDROID_TONEMAP_CURVE_GREEN).count/2;
6615 if (tonemapCurves.tonemap_points_cnt > CAM_MAX_TONEMAP_CURVE_SIZE) {
6616 ALOGE("%s: Fatal: tonemap_points_cnt %d exceeds max value of %d",
6617 __func__, tonemapCurves.tonemap_points_cnt,
6618 CAM_MAX_TONEMAP_CURVE_SIZE);
6619 tonemapCurves.tonemap_points_cnt = CAM_MAX_TONEMAP_CURVE_SIZE;
6620 }
6621
6622 /* ch0 = G*/
6623 int point = 0;
6624 cam_tonemap_curve_t tonemapCurveGreen;
6625 for (int i = 0; i < tonemapCurves.tonemap_points_cnt ; i++) {
6626 for (int j = 0; j < 2; j++) {
6627 tonemapCurveGreen.tonemap_points[i][j] =
6628 frame_settings.find(ANDROID_TONEMAP_CURVE_GREEN).data.f[point];
6629 point++;
6630 }
6631 }
6632 tonemapCurves.curves[0] = tonemapCurveGreen;
6633
6634 /* ch 1 = B */
6635 point = 0;
6636 cam_tonemap_curve_t tonemapCurveBlue;
6637 for (int i = 0; i < tonemapCurves.tonemap_points_cnt; i++) {
6638 for (int j = 0; j < 2; j++) {
6639 tonemapCurveBlue.tonemap_points[i][j] =
6640 frame_settings.find(ANDROID_TONEMAP_CURVE_BLUE).data.f[point];
6641 point++;
6642 }
6643 }
6644 tonemapCurves.curves[1] = tonemapCurveBlue;
6645
6646 /* ch 2 = R */
6647 point = 0;
6648 cam_tonemap_curve_t tonemapCurveRed;
6649 for (int i = 0; i < tonemapCurves.tonemap_points_cnt; i++) {
6650 for (int j = 0; j < 2; j++) {
6651 tonemapCurveRed.tonemap_points[i][j] =
6652 frame_settings.find(ANDROID_TONEMAP_CURVE_RED).data.f[point];
6653 point++;
6654 }
6655 }
6656 tonemapCurves.curves[2] = tonemapCurveRed;
6657
6658 rc = AddSetParmEntryToBatch(hal_metadata,
6659 CAM_INTF_META_TONEMAP_CURVES,
6660 sizeof(tonemapCurves), &tonemapCurves);
6661 }
6662
6663 if (frame_settings.exists(ANDROID_CONTROL_CAPTURE_INTENT)) {
6664 uint8_t captureIntent =
6665 frame_settings.find(ANDROID_CONTROL_CAPTURE_INTENT).data.u8[0];
6666 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_META_CAPTURE_INTENT,
6667 sizeof(captureIntent), &captureIntent);
6668 }
6669
6670 if (frame_settings.exists(ANDROID_BLACK_LEVEL_LOCK)) {
6671 uint8_t blackLevelLock =
6672 frame_settings.find(ANDROID_BLACK_LEVEL_LOCK).data.u8[0];
6673 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_META_BLACK_LEVEL_LOCK,
6674 sizeof(blackLevelLock), &blackLevelLock);
6675 }
6676
6677 if (frame_settings.exists(ANDROID_STATISTICS_LENS_SHADING_MAP_MODE)) {
6678 uint8_t lensShadingMapMode =
6679 frame_settings.find(ANDROID_STATISTICS_LENS_SHADING_MAP_MODE).data.u8[0];
6680 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_META_LENS_SHADING_MAP_MODE,
6681 sizeof(lensShadingMapMode), &lensShadingMapMode);
6682 }
6683
6684 if (frame_settings.exists(ANDROID_CONTROL_AE_REGIONS)) {
6685 cam_area_t roi;
6686 bool reset = true;
6687 convertFromRegions(&roi, request->settings, ANDROID_CONTROL_AE_REGIONS);
6688 if (scalerCropSet) {
6689 reset = resetIfNeededROI(&roi, &scalerCropRegion);
6690 }
6691 if (reset) {
6692 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_META_AEC_ROI,
6693 sizeof(roi), &roi);
6694 }
6695 }
6696
6697 if (frame_settings.exists(ANDROID_CONTROL_AF_REGIONS)) {
6698 cam_area_t roi;
6699 bool reset = true;
6700 convertFromRegions(&roi, request->settings, ANDROID_CONTROL_AF_REGIONS);
6701 if (scalerCropSet) {
6702 reset = resetIfNeededROI(&roi, &scalerCropRegion);
6703 }
6704 if (reset) {
6705 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_META_AF_ROI,
6706 sizeof(roi), &roi);
6707 }
6708 }
6709
6710 // CDS
6711 if (frame_settings.exists(QCAMERA3_CDS_MODE)) {
6712 int32_t* cds =
6713 frame_settings.find(QCAMERA3_CDS_MODE).data.i32;
6714 if ((CAM_CDS_MODE_MAX <= (*cds)) || (0 > (*cds))) {
6715 ALOGE("%s: Invalid CDS mode %d!", __func__, *cds);
6716 } else {
6717 cam_cds_mode_type_t mode = (cam_cds_mode_type_t) *cds;
6718 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_CDS_MODE,
6719 sizeof(mode), &mode);
6720 }
6721 }
6722
6723 if (frame_settings.exists(ANDROID_SENSOR_TEST_PATTERN_MODE)) {
6724 cam_test_pattern_data_t testPatternData;
6725 uint32_t fwk_testPatternMode = frame_settings.find(ANDROID_SENSOR_TEST_PATTERN_MODE).data.i32[0];
6726 uint8_t testPatternMode = lookupHalName(TEST_PATTERN_MAP,
6727 sizeof(TEST_PATTERN_MAP), fwk_testPatternMode);
6728
6729 memset(&testPatternData, 0, sizeof(testPatternData));
6730 testPatternData.mode = (cam_test_pattern_mode_t)testPatternMode;
6731 if (testPatternMode == CAM_TEST_PATTERN_SOLID_COLOR &&
6732 frame_settings.exists(ANDROID_SENSOR_TEST_PATTERN_DATA)) {
6733 int32_t* fwk_testPatternData = frame_settings.find(
6734 ANDROID_SENSOR_TEST_PATTERN_DATA).data.i32;
6735 testPatternData.r = fwk_testPatternData[0];
6736 testPatternData.b = fwk_testPatternData[3];
6737 switch (gCamCapability[mCameraId]->color_arrangement) {
6738 case CAM_FILTER_ARRANGEMENT_RGGB:
6739 case CAM_FILTER_ARRANGEMENT_GRBG:
6740 testPatternData.gr = fwk_testPatternData[1];
6741 testPatternData.gb = fwk_testPatternData[2];
6742 break;
6743 case CAM_FILTER_ARRANGEMENT_GBRG:
6744 case CAM_FILTER_ARRANGEMENT_BGGR:
6745 testPatternData.gr = fwk_testPatternData[2];
6746 testPatternData.gb = fwk_testPatternData[1];
6747 break;
6748 default:
6749 ALOGE("%s: color arrangement %d is not supported", __func__,
6750 gCamCapability[mCameraId]->color_arrangement);
6751 break;
6752 }
6753 }
6754 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_META_TEST_PATTERN_DATA,
6755 sizeof(testPatternData), &testPatternData);
6756 }
6757
6758 if (frame_settings.exists(ANDROID_JPEG_GPS_COORDINATES)) {
6759 double *gps_coords =
6760 frame_settings.find(ANDROID_JPEG_GPS_COORDINATES).data.d;
6761 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_META_JPEG_GPS_COORDINATES, sizeof(double)*3, gps_coords);
6762 }
6763
6764 if (frame_settings.exists(ANDROID_JPEG_GPS_PROCESSING_METHOD)) {
6765 char gps_methods[GPS_PROCESSING_METHOD_SIZE];
6766 const char *gps_methods_src = (const char *)
6767 frame_settings.find(ANDROID_JPEG_GPS_PROCESSING_METHOD).data.u8;
6768 memset(gps_methods, '\0', sizeof(gps_methods));
6769 strncpy(gps_methods, gps_methods_src, sizeof(gps_methods)-1);
6770 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_META_JPEG_GPS_PROC_METHODS, sizeof(gps_methods), gps_methods);
6771 }
6772
6773 if (frame_settings.exists(ANDROID_JPEG_GPS_TIMESTAMP)) {
6774 int64_t gps_timestamp =
6775 frame_settings.find(ANDROID_JPEG_GPS_TIMESTAMP).data.i64[0];
6776 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_META_JPEG_GPS_TIMESTAMP, sizeof(int64_t), &gps_timestamp);
6777 }
6778
6779 if (frame_settings.exists(ANDROID_JPEG_ORIENTATION)) {
6780 int32_t orientation =
6781 frame_settings.find(ANDROID_JPEG_ORIENTATION).data.i32[0];
6782 cam_rotation_info_t rotation_info;
6783 if (orientation == 0) {
6784 rotation_info.rotation = ROTATE_0;
6785 } else if (orientation == 90) {
6786 rotation_info.rotation = ROTATE_90;
6787 } else if (orientation == 180) {
6788 rotation_info.rotation = ROTATE_180;
6789 } else if (orientation == 270) {
6790 rotation_info.rotation = ROTATE_270;
6791 }
6792 rotation_info.streamId = snapshotStreamId;
6793 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_META_JPEG_ORIENTATION, sizeof(orientation), &orientation);
6794 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_PARM_ROTATION, sizeof(rotation_info), &rotation_info);
6795 }
6796
6797 if (frame_settings.exists(ANDROID_JPEG_QUALITY)) {
6798 int8_t quality =
6799 frame_settings.find(ANDROID_JPEG_QUALITY).data.u8[0];
6800 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_META_JPEG_QUALITY, sizeof(quality), &quality);
6801 }
6802
6803 if (frame_settings.exists(ANDROID_JPEG_THUMBNAIL_QUALITY)) {
6804 int8_t thumb_quality =
6805 frame_settings.find(ANDROID_JPEG_THUMBNAIL_QUALITY).data.u8[0];
6806 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_META_JPEG_THUMB_QUALITY, sizeof(thumb_quality), &thumb_quality);
6807 }
6808
6809 if (frame_settings.exists(ANDROID_JPEG_THUMBNAIL_SIZE)) {
6810 cam_dimension_t dim;
6811 dim.width = frame_settings.find(ANDROID_JPEG_THUMBNAIL_SIZE).data.i32[0];
6812 dim.height = frame_settings.find(ANDROID_JPEG_THUMBNAIL_SIZE).data.i32[1];
6813 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_META_JPEG_THUMB_SIZE, sizeof(dim), &dim);
6814 }
6815
6816 // Internal metadata
6817 if (frame_settings.exists(QCAMERA3_PRIVATEDATA_REPROCESS)) {
6818 int32_t* privatedata =
6819 frame_settings.find(QCAMERA3_PRIVATEDATA_REPROCESS).data.i32;
6820 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_META_PRIVATE_DATA,
6821 sizeof(int32_t) * MAX_METADATA_PRIVATE_PAYLOAD_SIZE, privatedata);
6822 }
6823
6824 if (frame_settings.exists(QCAMERA3_USE_AV_TIMER)) {
6825 uint8_t* use_av_timer =
6826 frame_settings.find(QCAMERA3_USE_AV_TIMER).data.u8;
6827 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_META_USE_AV_TIMER,
6828 sizeof(uint8_t), use_av_timer);
6829 }
6830
6831 // EV step
6832 rc = AddSetParmEntryToBatch(hal_metadata, CAM_INTF_PARM_EV_STEP,
6833 sizeof(cam_rational_type_t), &(gCamCapability[mCameraId]->exp_compensation_step));
6834
6835 return rc;
6836 }
6837
6838 /*===========================================================================
6839 * FUNCTION : captureResultCb
6840 *
6841 * DESCRIPTION: Callback handler for all channels (streams, as well as metadata)
6842 *
6843 * PARAMETERS :
6844 * @frame : frame information from mm-camera-interface
6845 * @buffer : actual gralloc buffer to be returned to frameworks. NULL if metadata.
6846 * @userdata: userdata
6847 *
6848 * RETURN : NONE
6849 *==========================================================================*/
captureResultCb(mm_camera_super_buf_t * metadata,camera3_stream_buffer_t * buffer,uint32_t frame_number,void * userdata)6850 void QCamera3HardwareInterface::captureResultCb(mm_camera_super_buf_t *metadata,
6851 camera3_stream_buffer_t *buffer,
6852 uint32_t frame_number, void *userdata)
6853 {
6854 QCamera3HardwareInterface *hw = (QCamera3HardwareInterface *)userdata;
6855 if (hw == NULL) {
6856 ALOGE("%s: Invalid hw %p", __func__, hw);
6857 return;
6858 }
6859
6860 hw->captureResultCb(metadata, buffer, frame_number);
6861 return;
6862 }
6863
6864
6865 /*===========================================================================
6866 * FUNCTION : initialize
6867 *
6868 * DESCRIPTION: Pass framework callback pointers to HAL
6869 *
6870 * PARAMETERS :
6871 *
6872 *
6873 * RETURN : Success : 0
6874 * Failure: -ENODEV
6875 *==========================================================================*/
6876
initialize(const struct camera3_device * device,const camera3_callback_ops_t * callback_ops)6877 int QCamera3HardwareInterface::initialize(const struct camera3_device *device,
6878 const camera3_callback_ops_t *callback_ops)
6879 {
6880 CDBG("%s: E", __func__);
6881 QCamera3HardwareInterface *hw =
6882 reinterpret_cast<QCamera3HardwareInterface *>(device->priv);
6883 if (!hw) {
6884 ALOGE("%s: NULL camera device", __func__);
6885 return -ENODEV;
6886 }
6887
6888 int rc = hw->initialize(callback_ops);
6889 CDBG("%s: X", __func__);
6890 return rc;
6891 }
6892
6893 /*===========================================================================
6894 * FUNCTION : configure_streams
6895 *
6896 * DESCRIPTION:
6897 *
6898 * PARAMETERS :
6899 *
6900 *
6901 * RETURN : Success: 0
6902 * Failure: -EINVAL (if stream configuration is invalid)
6903 * -ENODEV (fatal error)
6904 *==========================================================================*/
6905
configure_streams(const struct camera3_device * device,camera3_stream_configuration_t * stream_list)6906 int QCamera3HardwareInterface::configure_streams(
6907 const struct camera3_device *device,
6908 camera3_stream_configuration_t *stream_list)
6909 {
6910 CDBG("%s: E", __func__);
6911 QCamera3HardwareInterface *hw =
6912 reinterpret_cast<QCamera3HardwareInterface *>(device->priv);
6913 if (!hw) {
6914 ALOGE("%s: NULL camera device", __func__);
6915 return -ENODEV;
6916 }
6917 int rc = hw->configureStreams(stream_list);
6918 CDBG("%s: X", __func__);
6919 return rc;
6920 }
6921
6922 /*===========================================================================
6923 * FUNCTION : construct_default_request_settings
6924 *
6925 * DESCRIPTION: Configure a settings buffer to meet the required use case
6926 *
6927 * PARAMETERS :
6928 *
6929 *
6930 * RETURN : Success: Return valid metadata
6931 * Failure: Return NULL
6932 *==========================================================================*/
6933 const camera_metadata_t* QCamera3HardwareInterface::
construct_default_request_settings(const struct camera3_device * device,int type)6934 construct_default_request_settings(const struct camera3_device *device,
6935 int type)
6936 {
6937
6938 CDBG("%s: E", __func__);
6939 camera_metadata_t* fwk_metadata = NULL;
6940 QCamera3HardwareInterface *hw =
6941 reinterpret_cast<QCamera3HardwareInterface *>(device->priv);
6942 if (!hw) {
6943 ALOGE("%s: NULL camera device", __func__);
6944 return NULL;
6945 }
6946
6947 fwk_metadata = hw->translateCapabilityToMetadata(type);
6948
6949 CDBG("%s: X", __func__);
6950 return fwk_metadata;
6951 }
6952
6953 /*===========================================================================
6954 * FUNCTION : process_capture_request
6955 *
6956 * DESCRIPTION:
6957 *
6958 * PARAMETERS :
6959 *
6960 *
6961 * RETURN :
6962 *==========================================================================*/
process_capture_request(const struct camera3_device * device,camera3_capture_request_t * request)6963 int QCamera3HardwareInterface::process_capture_request(
6964 const struct camera3_device *device,
6965 camera3_capture_request_t *request)
6966 {
6967 CDBG("%s: E", __func__);
6968 QCamera3HardwareInterface *hw =
6969 reinterpret_cast<QCamera3HardwareInterface *>(device->priv);
6970 if (!hw) {
6971 ALOGE("%s: NULL camera device", __func__);
6972 return -EINVAL;
6973 }
6974
6975 int rc = hw->processCaptureRequest(request);
6976 CDBG("%s: X", __func__);
6977 return rc;
6978 }
6979
6980 /*===========================================================================
6981 * FUNCTION : dump
6982 *
6983 * DESCRIPTION:
6984 *
6985 * PARAMETERS :
6986 *
6987 *
6988 * RETURN :
6989 *==========================================================================*/
6990
dump(const struct camera3_device * device,int fd)6991 void QCamera3HardwareInterface::dump(
6992 const struct camera3_device *device, int fd)
6993 {
6994 /* Log level property is read when "adb shell dumpsys media.camera" is
6995 called so that the log level can be controlled without restarting
6996 the media server */
6997 getLogLevel();
6998
6999 CDBG("%s: E", __func__);
7000 QCamera3HardwareInterface *hw =
7001 reinterpret_cast<QCamera3HardwareInterface *>(device->priv);
7002 if (!hw) {
7003 ALOGE("%s: NULL camera device", __func__);
7004 return;
7005 }
7006
7007 hw->dump(fd);
7008 CDBG("%s: X", __func__);
7009 return;
7010 }
7011
7012 /*===========================================================================
7013 * FUNCTION : flush
7014 *
7015 * DESCRIPTION:
7016 *
7017 * PARAMETERS :
7018 *
7019 *
7020 * RETURN :
7021 *==========================================================================*/
7022
flush(const struct camera3_device * device)7023 int QCamera3HardwareInterface::flush(
7024 const struct camera3_device *device)
7025 {
7026 int rc;
7027 CDBG("%s: E", __func__);
7028 QCamera3HardwareInterface *hw =
7029 reinterpret_cast<QCamera3HardwareInterface *>(device->priv);
7030 if (!hw) {
7031 ALOGE("%s: NULL camera device", __func__);
7032 return -EINVAL;
7033 }
7034
7035 rc = hw->flush();
7036 CDBG("%s: X", __func__);
7037 return rc;
7038 }
7039
7040 /*===========================================================================
7041 * FUNCTION : close_camera_device
7042 *
7043 * DESCRIPTION:
7044 *
7045 * PARAMETERS :
7046 *
7047 *
7048 * RETURN :
7049 *==========================================================================*/
close_camera_device(struct hw_device_t * device)7050 int QCamera3HardwareInterface::close_camera_device(struct hw_device_t* device)
7051 {
7052 CDBG("%s: E", __func__);
7053 int ret = NO_ERROR;
7054 QCamera3HardwareInterface *hw =
7055 reinterpret_cast<QCamera3HardwareInterface *>(
7056 reinterpret_cast<camera3_device_t *>(device)->priv);
7057 if (!hw) {
7058 ALOGE("NULL camera device");
7059 return BAD_VALUE;
7060 }
7061 delete hw;
7062
7063 CDBG("%s: X", __func__);
7064 return ret;
7065 }
7066
7067 /*===========================================================================
7068 * FUNCTION : getWaveletDenoiseProcessPlate
7069 *
7070 * DESCRIPTION: query wavelet denoise process plate
7071 *
7072 * PARAMETERS : None
7073 *
7074 * RETURN : WNR prcocess plate vlaue
7075 *==========================================================================*/
getWaveletDenoiseProcessPlate()7076 cam_denoise_process_type_t QCamera3HardwareInterface::getWaveletDenoiseProcessPlate()
7077 {
7078 char prop[PROPERTY_VALUE_MAX];
7079 memset(prop, 0, sizeof(prop));
7080 property_get("persist.denoise.process.plates", prop, "0");
7081 int processPlate = atoi(prop);
7082 switch(processPlate) {
7083 case 0:
7084 return CAM_WAVELET_DENOISE_YCBCR_PLANE;
7085 case 1:
7086 return CAM_WAVELET_DENOISE_CBCR_ONLY;
7087 case 2:
7088 return CAM_WAVELET_DENOISE_STREAMLINE_YCBCR;
7089 case 3:
7090 return CAM_WAVELET_DENOISE_STREAMLINED_CBCR;
7091 default:
7092 return CAM_WAVELET_DENOISE_STREAMLINE_YCBCR;
7093 }
7094 }
7095
7096 /*===========================================================================
7097 * FUNCTION : needRotationReprocess
7098 *
7099 * DESCRIPTION: if rotation needs to be done by reprocess in pp
7100 *
7101 * PARAMETERS : none
7102 *
7103 * RETURN : true: needed
7104 * false: no need
7105 *==========================================================================*/
needRotationReprocess()7106 bool QCamera3HardwareInterface::needRotationReprocess()
7107 {
7108 if ((gCamCapability[mCameraId]->qcom_supported_feature_mask & CAM_QCOM_FEATURE_ROTATION) > 0) {
7109 // current rotation is not zero, and pp has the capability to process rotation
7110 CDBG_HIGH("%s: need do reprocess for rotation", __func__);
7111 return true;
7112 }
7113
7114 return false;
7115 }
7116
7117 /*===========================================================================
7118 * FUNCTION : needReprocess
7119 *
7120 * DESCRIPTION: if reprocess in needed
7121 *
7122 * PARAMETERS : none
7123 *
7124 * RETURN : true: needed
7125 * false: no need
7126 *==========================================================================*/
needReprocess(uint32_t postprocess_mask)7127 bool QCamera3HardwareInterface::needReprocess(uint32_t postprocess_mask)
7128 {
7129 if (gCamCapability[mCameraId]->min_required_pp_mask > 0) {
7130 // TODO: add for ZSL HDR later
7131 // pp module has min requirement for zsl reprocess, or WNR in ZSL mode
7132 if(postprocess_mask == CAM_QCOM_FEATURE_NONE){
7133 CDBG_HIGH("%s: need do reprocess for ZSL WNR or min PP reprocess", __func__);
7134 return true;
7135 } else {
7136 CDBG_HIGH("%s: already post processed frame", __func__);
7137 return false;
7138 }
7139 }
7140 return needRotationReprocess();
7141 }
7142
7143 /*===========================================================================
7144 * FUNCTION : needJpegRotation
7145 *
7146 * DESCRIPTION: if rotation from jpeg is needed
7147 *
7148 * PARAMETERS : none
7149 *
7150 * RETURN : true: needed
7151 * false: no need
7152 *==========================================================================*/
needJpegRotation()7153 bool QCamera3HardwareInterface::needJpegRotation()
7154 {
7155 /*If the pp does not have the ability to do rotation, enable jpeg rotation*/
7156 if (!(gCamCapability[mCameraId]->qcom_supported_feature_mask & CAM_QCOM_FEATURE_ROTATION)) {
7157 CDBG("%s: Need Jpeg to do the rotation", __func__);
7158 return true;
7159 }
7160 return false;
7161 }
7162
7163 /*===========================================================================
7164 * FUNCTION : addOfflineReprocChannel
7165 *
7166 * DESCRIPTION: add a reprocess channel that will do reprocess on frames
7167 * coming from input channel
7168 *
7169 * PARAMETERS :
7170 * @config : reprocess configuration
7171 *
7172 *
7173 * RETURN : Ptr to the newly created channel obj. NULL if failed.
7174 *==========================================================================*/
addOfflineReprocChannel(const reprocess_config_t & config,QCamera3PicChannel * picChHandle,metadata_buffer_t * metadata)7175 QCamera3ReprocessChannel *QCamera3HardwareInterface::addOfflineReprocChannel(
7176 const reprocess_config_t &config, QCamera3PicChannel *picChHandle,
7177 metadata_buffer_t *metadata)
7178 {
7179 int32_t rc = NO_ERROR;
7180 QCamera3ReprocessChannel *pChannel = NULL;
7181
7182 pChannel = new QCamera3ReprocessChannel(mCameraHandle->camera_handle,
7183 mCameraHandle->ops, NULL, config.padding, CAM_QCOM_FEATURE_NONE, this, picChHandle);
7184 if (NULL == pChannel) {
7185 ALOGE("%s: no mem for reprocess channel", __func__);
7186 return NULL;
7187 }
7188
7189 rc = pChannel->initialize(IS_TYPE_NONE);
7190 if (rc != NO_ERROR) {
7191 ALOGE("%s: init reprocess channel failed, ret = %d", __func__, rc);
7192 delete pChannel;
7193 return NULL;
7194 }
7195
7196 // pp feature config
7197 cam_pp_feature_config_t pp_config;
7198 memset(&pp_config, 0, sizeof(cam_pp_feature_config_t));
7199
7200 pp_config.feature_mask |= CAM_QCOM_FEATURE_PP_SUPERSET;
7201
7202 rc = pChannel->addReprocStreamsFromSource(pp_config,
7203 config,
7204 IS_TYPE_NONE,
7205 mMetadataChannel);
7206
7207 if (rc != NO_ERROR) {
7208 delete pChannel;
7209 return NULL;
7210 }
7211 return pChannel;
7212 }
7213
7214
isCACEnabled()7215 bool QCamera3HardwareInterface::isCACEnabled() {
7216 char prop[PROPERTY_VALUE_MAX];
7217 memset(prop, 0, sizeof(prop));
7218 property_get("persist.camera.feature.cac", prop, "0");
7219 int enableCAC = atoi(prop);
7220 return enableCAC;
7221 }
7222 /*===========================================================================
7223 * FUNCTION : getLogLevel
7224 *
7225 * DESCRIPTION: Reads the log level property into a variable
7226 *
7227 * PARAMETERS :
7228 * None
7229 *
7230 * RETURN :
7231 * None
7232 *==========================================================================*/
getLogLevel()7233 void QCamera3HardwareInterface::getLogLevel()
7234 {
7235 char prop[PROPERTY_VALUE_MAX];
7236
7237 property_get("persist.camera.logs", prop, "0");
7238 gCamHal3LogLevel = atoi(prop);
7239
7240 return;
7241 }
7242
7243 /*===========================================================================
7244 * FUNCTION : getFlashInfo
7245 *
7246 * DESCRIPTION: Retrieve information about whether the device has a flash.
7247 *
7248 * PARAMETERS :
7249 * @cameraId : Camera id to query
7250 * @hasFlash : Boolean indicating whether there is a flash device
7251 * associated with given camera
7252 * @flashNode : If a flash device exists, this will be its device node.
7253 *
7254 * RETURN :
7255 * None
7256 *==========================================================================*/
getFlashInfo(const int cameraId,bool & hasFlash,char (& flashNode)[QCAMERA_MAX_FILEPATH_LENGTH])7257 void QCamera3HardwareInterface::getFlashInfo(const int cameraId,
7258 bool& hasFlash,
7259 char (&flashNode)[QCAMERA_MAX_FILEPATH_LENGTH])
7260 {
7261 cam_capability_t* camCapability = gCamCapability[cameraId];
7262 if (NULL == camCapability) {
7263 hasFlash = false;
7264 flashNode[0] = '\0';
7265 } else {
7266 hasFlash = camCapability->flash_available;
7267 strlcpy(flashNode,
7268 (char*)camCapability->flash_dev_name,
7269 QCAMERA_MAX_FILEPATH_LENGTH);
7270 }
7271 }
7272
7273 /*===========================================================================
7274 * FUNCTION : validateStreamRotations
7275 *
7276 * DESCRIPTION: Check if the rotations requested are supported
7277 *
7278 * PARAMETERS :
7279 * @stream_list : streams to be configured
7280 *
7281 * RETURN : NO_ERROR on success
7282 * -EINVAL on failure
7283 *
7284 *==========================================================================*/
validateStreamRotations(camera3_stream_configuration_t * streamList)7285 int QCamera3HardwareInterface::validateStreamRotations(
7286 camera3_stream_configuration_t *streamList)
7287 {
7288 int rc = NO_ERROR;
7289
7290 /*
7291 * Loop through all streams requested in configuration
7292 * Check if unsupported rotations have been requested on any of them
7293 */
7294 for (size_t j = 0; j < streamList->num_streams; j++){
7295 camera3_stream_t *newStream = streamList->streams[j];
7296
7297 bool isRotated = (newStream->rotation != CAMERA3_STREAM_ROTATION_0);
7298 bool isImplDef = (newStream->format ==
7299 HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED);
7300 bool isZsl = (newStream->stream_type == CAMERA3_STREAM_BIDIRECTIONAL &&
7301 isImplDef);
7302
7303 if (isRotated && (!isImplDef || isZsl)) {
7304 ALOGE("%s: Error: Unsupported rotation of %d requested for stream"
7305 "type:%d and stream format:%d", __func__,
7306 newStream->rotation, newStream->stream_type,
7307 newStream->format);
7308 rc = -EINVAL;
7309 break;
7310 }
7311 }
7312
7313 return rc;
7314 }
7315
7316 }; //end namespace qcamera
7317