QCamera3HWI.cpp revision ea44a483c0e98200c058a85ea339457616516847 
1/* Copyright (c) 2012-2013, 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 LOG_TAG "QCamera3HWI"
31
32#include <cutils/properties.h>
33#include <hardware/camera3.h>
34#include <camera/CameraMetadata.h>
35#include <stdlib.h>
36#include <utils/Log.h>
37#include <utils/Errors.h>
38#include <ui/Fence.h>
39#include <gralloc_priv.h>
40#include "QCamera3HWI.h"
41#include "QCamera3Mem.h"
42#include "QCamera3Channel.h"
43#include "QCamera3PostProc.h"
44
45using namespace android;
46
47namespace qcamera {
48#define DATA_PTR(MEM_OBJ,INDEX) MEM_OBJ->getPtr( INDEX )
49cam_capability_t *gCamCapability[MM_CAMERA_MAX_NUM_SENSORS];
50parm_buffer_t *prevSettings;
51const camera_metadata_t *gStaticMetadata[MM_CAMERA_MAX_NUM_SENSORS];
52
53pthread_mutex_t QCamera3HardwareInterface::mCameraSessionLock =
54    PTHREAD_MUTEX_INITIALIZER;
55unsigned int QCamera3HardwareInterface::mCameraSessionActive = 0;
56
57const QCamera3HardwareInterface::QCameraMap QCamera3HardwareInterface::EFFECT_MODES_MAP[] = {
58    { ANDROID_CONTROL_EFFECT_MODE_OFF,       CAM_EFFECT_MODE_OFF },
59    { ANDROID_CONTROL_EFFECT_MODE_MONO,       CAM_EFFECT_MODE_MONO },
60    { ANDROID_CONTROL_EFFECT_MODE_NEGATIVE,   CAM_EFFECT_MODE_NEGATIVE },
61    { ANDROID_CONTROL_EFFECT_MODE_SOLARIZE,   CAM_EFFECT_MODE_SOLARIZE },
62    { ANDROID_CONTROL_EFFECT_MODE_SEPIA,      CAM_EFFECT_MODE_SEPIA },
63    { ANDROID_CONTROL_EFFECT_MODE_POSTERIZE,  CAM_EFFECT_MODE_POSTERIZE },
64    { ANDROID_CONTROL_EFFECT_MODE_WHITEBOARD, CAM_EFFECT_MODE_WHITEBOARD },
65    { ANDROID_CONTROL_EFFECT_MODE_BLACKBOARD, CAM_EFFECT_MODE_BLACKBOARD },
66    { ANDROID_CONTROL_EFFECT_MODE_AQUA,       CAM_EFFECT_MODE_AQUA }
67};
68
69const QCamera3HardwareInterface::QCameraMap QCamera3HardwareInterface::WHITE_BALANCE_MODES_MAP[] = {
70    { ANDROID_CONTROL_AWB_MODE_OFF,             CAM_WB_MODE_OFF },
71    { ANDROID_CONTROL_AWB_MODE_AUTO,            CAM_WB_MODE_AUTO },
72    { ANDROID_CONTROL_AWB_MODE_INCANDESCENT,    CAM_WB_MODE_INCANDESCENT },
73    { ANDROID_CONTROL_AWB_MODE_FLUORESCENT,     CAM_WB_MODE_FLUORESCENT },
74    { ANDROID_CONTROL_AWB_MODE_WARM_FLUORESCENT,CAM_WB_MODE_WARM_FLUORESCENT},
75    { ANDROID_CONTROL_AWB_MODE_DAYLIGHT,        CAM_WB_MODE_DAYLIGHT },
76    { ANDROID_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT, CAM_WB_MODE_CLOUDY_DAYLIGHT },
77    { ANDROID_CONTROL_AWB_MODE_TWILIGHT,        CAM_WB_MODE_TWILIGHT },
78    { ANDROID_CONTROL_AWB_MODE_SHADE,           CAM_WB_MODE_SHADE }
79};
80
81const QCamera3HardwareInterface::QCameraMap QCamera3HardwareInterface::SCENE_MODES_MAP[] = {
82    { ANDROID_CONTROL_SCENE_MODE_ACTION,         CAM_SCENE_MODE_ACTION },
83    { ANDROID_CONTROL_SCENE_MODE_PORTRAIT,       CAM_SCENE_MODE_PORTRAIT },
84    { ANDROID_CONTROL_SCENE_MODE_LANDSCAPE,      CAM_SCENE_MODE_LANDSCAPE },
85    { ANDROID_CONTROL_SCENE_MODE_NIGHT,          CAM_SCENE_MODE_NIGHT },
86    { ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT, CAM_SCENE_MODE_NIGHT_PORTRAIT },
87    { ANDROID_CONTROL_SCENE_MODE_THEATRE,        CAM_SCENE_MODE_THEATRE },
88    { ANDROID_CONTROL_SCENE_MODE_BEACH,          CAM_SCENE_MODE_BEACH },
89    { ANDROID_CONTROL_SCENE_MODE_SNOW,           CAM_SCENE_MODE_SNOW },
90    { ANDROID_CONTROL_SCENE_MODE_SUNSET,         CAM_SCENE_MODE_SUNSET },
91    { ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO,    CAM_SCENE_MODE_ANTISHAKE },
92    { ANDROID_CONTROL_SCENE_MODE_FIREWORKS ,     CAM_SCENE_MODE_FIREWORKS },
93    { ANDROID_CONTROL_SCENE_MODE_SPORTS ,        CAM_SCENE_MODE_SPORTS },
94    { ANDROID_CONTROL_SCENE_MODE_PARTY,          CAM_SCENE_MODE_PARTY },
95    { ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT,    CAM_SCENE_MODE_CANDLELIGHT },
96    { ANDROID_CONTROL_SCENE_MODE_BARCODE,        CAM_SCENE_MODE_BARCODE}
97};
98
99const QCamera3HardwareInterface::QCameraMap QCamera3HardwareInterface::FOCUS_MODES_MAP[] = {
100    { ANDROID_CONTROL_AF_MODE_OFF,                CAM_FOCUS_MODE_FIXED },
101    { ANDROID_CONTROL_AF_MODE_AUTO,               CAM_FOCUS_MODE_AUTO },
102    { ANDROID_CONTROL_AF_MODE_MACRO,              CAM_FOCUS_MODE_MACRO },
103    { ANDROID_CONTROL_AF_MODE_EDOF,               CAM_FOCUS_MODE_EDOF },
104    { ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE, CAM_FOCUS_MODE_CONTINOUS_PICTURE },
105    { ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO,   CAM_FOCUS_MODE_CONTINOUS_VIDEO }
106};
107
108const QCamera3HardwareInterface::QCameraMap QCamera3HardwareInterface::ANTIBANDING_MODES_MAP[] = {
109    { ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF,  CAM_ANTIBANDING_MODE_OFF },
110    { ANDROID_CONTROL_AE_ANTIBANDING_MODE_50HZ, CAM_ANTIBANDING_MODE_50HZ },
111    { ANDROID_CONTROL_AE_ANTIBANDING_MODE_60HZ, CAM_ANTIBANDING_MODE_60HZ },
112    { ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO, CAM_ANTIBANDING_MODE_AUTO }
113};
114
115const QCamera3HardwareInterface::QCameraMap QCamera3HardwareInterface::AE_FLASH_MODE_MAP[] = {
116    { ANDROID_CONTROL_AE_MODE_OFF,                  CAM_FLASH_MODE_OFF },
117    { ANDROID_CONTROL_AE_MODE_ON,                   CAM_FLASH_MODE_OFF },
118    { ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH,        CAM_FLASH_MODE_AUTO},
119    { ANDROID_CONTROL_AE_MODE_ON_ALWAYS_FLASH,      CAM_FLASH_MODE_ON  },
120    { ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE, CAM_FLASH_MODE_AUTO}
121};
122
123const QCamera3HardwareInterface::QCameraMap QCamera3HardwareInterface::FLASH_MODES_MAP[] = {
124    { ANDROID_FLASH_MODE_OFF,    CAM_FLASH_MODE_OFF  },
125    { ANDROID_FLASH_MODE_SINGLE, CAM_FLASH_MODE_ON   },
126    { ANDROID_FLASH_MODE_TORCH,  CAM_FLASH_MODE_TORCH}
127};
128
129const int32_t available_thumbnail_sizes[] = {512, 288, 480, 288, 256, 154, 432, 288,
130                                             320, 240, 176, 144, 0, 0};
131
132camera3_device_ops_t QCamera3HardwareInterface::mCameraOps = {
133    initialize:                         QCamera3HardwareInterface::initialize,
134    configure_streams:                  QCamera3HardwareInterface::configure_streams,
135    register_stream_buffers:            QCamera3HardwareInterface::register_stream_buffers,
136    construct_default_request_settings: QCamera3HardwareInterface::construct_default_request_settings,
137    process_capture_request:            QCamera3HardwareInterface::process_capture_request,
138    get_metadata_vendor_tag_ops:        QCamera3HardwareInterface::get_metadata_vendor_tag_ops,
139    dump:                               QCamera3HardwareInterface::dump,
140};
141
142
143/*===========================================================================
144 * FUNCTION   : QCamera3HardwareInterface
145 *
146 * DESCRIPTION: constructor of QCamera3HardwareInterface
147 *
148 * PARAMETERS :
149 *   @cameraId  : camera ID
150 *
151 * RETURN     : none
152 *==========================================================================*/
153QCamera3HardwareInterface::QCamera3HardwareInterface(int cameraId)
154    : mCameraId(cameraId),
155      mCameraHandle(NULL),
156      mCameraOpened(false),
157      mCameraInitialized(false),
158      mCallbackOps(NULL),
159      mInputStream(NULL),
160      mMetadataChannel(NULL),
161      mFirstRequest(false),
162      mParamHeap(NULL),
163      mParameters(NULL),
164      mJpegSettings(NULL),
165      m_pPowerModule(NULL)
166{
167    mCameraDevice.common.tag = HARDWARE_DEVICE_TAG;
168    mCameraDevice.common.version = CAMERA_DEVICE_API_VERSION_3_0;
169    mCameraDevice.common.close = close_camera_device;
170    mCameraDevice.ops = &mCameraOps;
171    mCameraDevice.priv = this;
172    gCamCapability[cameraId]->version = CAM_HAL_V3;
173
174    pthread_mutex_init(&mRequestLock, NULL);
175    pthread_cond_init(&mRequestCond, NULL);
176    mPendingRequest = 0;
177    mCurrentRequestId = -1;
178
179    pthread_mutex_init(&mMutex, NULL);
180    pthread_mutex_init(&mCaptureResultLock, NULL);
181
182    for (size_t i = 0; i < CAMERA3_TEMPLATE_COUNT; i++)
183        mDefaultMetadata[i] = NULL;
184
185#ifdef HAS_MULTIMEDIA_HINTS
186    if (hw_get_module(POWER_HARDWARE_MODULE_ID, (const hw_module_t **)&m_pPowerModule)) {
187        ALOGE("%s: %s module not found", __func__, POWER_HARDWARE_MODULE_ID);
188    }
189#endif
190}
191
192/*===========================================================================
193 * FUNCTION   : ~QCamera3HardwareInterface
194 *
195 * DESCRIPTION: destructor of QCamera3HardwareInterface
196 *
197 * PARAMETERS : none
198 *
199 * RETURN     : none
200 *==========================================================================*/
201QCamera3HardwareInterface::~QCamera3HardwareInterface()
202{
203    ALOGV("%s: E", __func__);
204    /* We need to stop all streams before deleting any stream */
205    for (List<stream_info_t *>::iterator it = mStreamInfo.begin();
206        it != mStreamInfo.end(); it++) {
207        QCamera3Channel *channel = (QCamera3Channel *)(*it)->stream->priv;
208        if (channel)
209            channel->stop();
210    }
211    for (List<stream_info_t *>::iterator it = mStreamInfo.begin();
212        it != mStreamInfo.end(); it++) {
213        QCamera3Channel *channel = (QCamera3Channel *)(*it)->stream->priv;
214        if (channel)
215            delete channel;
216        free (*it);
217    }
218
219    if (mJpegSettings != NULL) {
220        free(mJpegSettings);
221        mJpegSettings = NULL;
222    }
223
224    /* Clean up all channels */
225    if (mCameraInitialized) {
226        if (mMetadataChannel) {
227            mMetadataChannel->stop();
228            delete mMetadataChannel;
229            mMetadataChannel = NULL;
230        }
231        deinitParameters();
232    }
233
234    if (mCameraOpened)
235        closeCamera();
236
237    for (size_t i = 0; i < CAMERA3_TEMPLATE_COUNT; i++)
238        if (mDefaultMetadata[i])
239            free_camera_metadata(mDefaultMetadata[i]);
240
241    pthread_mutex_destroy(&mRequestLock);
242    pthread_cond_destroy(&mRequestCond);
243
244    pthread_mutex_destroy(&mMutex);
245    pthread_mutex_destroy(&mCaptureResultLock);
246    ALOGV("%s: X", __func__);
247}
248
249/*===========================================================================
250 * FUNCTION   : openCamera
251 *
252 * DESCRIPTION: open camera
253 *
254 * PARAMETERS :
255 *   @hw_device  : double ptr for camera device struct
256 *
257 * RETURN     : int32_t type of status
258 *              NO_ERROR  -- success
259 *              none-zero failure code
260 *==========================================================================*/
261int QCamera3HardwareInterface::openCamera(struct hw_device_t **hw_device)
262{
263    int rc = 0;
264    pthread_mutex_lock(&mCameraSessionLock);
265    if (mCameraSessionActive) {
266        ALOGE("%s: multiple simultaneous camera instance not supported", __func__);
267        pthread_mutex_unlock(&mCameraSessionLock);
268        return INVALID_OPERATION;
269    }
270
271    if (mCameraOpened) {
272        *hw_device = NULL;
273        return PERMISSION_DENIED;
274    }
275
276    rc = openCamera();
277    if (rc == 0) {
278        *hw_device = &mCameraDevice.common;
279        mCameraSessionActive = 1;
280    } else
281        *hw_device = NULL;
282
283#ifdef HAS_MULTIMEDIA_HINTS
284    if (rc == 0) {
285        if (m_pPowerModule) {
286            if (m_pPowerModule->powerHint) {
287                m_pPowerModule->powerHint(m_pPowerModule, POWER_HINT_VIDEO_ENCODE,
288                        (void *)"state=1");
289            }
290        }
291    }
292#endif
293    pthread_mutex_unlock(&mCameraSessionLock);
294    return rc;
295}
296
297/*===========================================================================
298 * FUNCTION   : openCamera
299 *
300 * DESCRIPTION: open camera
301 *
302 * PARAMETERS : none
303 *
304 * RETURN     : int32_t type of status
305 *              NO_ERROR  -- success
306 *              none-zero failure code
307 *==========================================================================*/
308int QCamera3HardwareInterface::openCamera()
309{
310    if (mCameraHandle) {
311        ALOGE("Failure: Camera already opened");
312        return ALREADY_EXISTS;
313    }
314    mCameraHandle = camera_open(mCameraId);
315    if (!mCameraHandle) {
316        ALOGE("camera_open failed.");
317        return UNKNOWN_ERROR;
318    }
319
320    mCameraOpened = true;
321
322    return NO_ERROR;
323}
324
325/*===========================================================================
326 * FUNCTION   : closeCamera
327 *
328 * DESCRIPTION: close camera
329 *
330 * PARAMETERS : none
331 *
332 * RETURN     : int32_t type of status
333 *              NO_ERROR  -- success
334 *              none-zero failure code
335 *==========================================================================*/
336int QCamera3HardwareInterface::closeCamera()
337{
338    int rc = NO_ERROR;
339
340    rc = mCameraHandle->ops->close_camera(mCameraHandle->camera_handle);
341    mCameraHandle = NULL;
342    mCameraOpened = false;
343
344#ifdef HAS_MULTIMEDIA_HINTS
345    if (rc == NO_ERROR) {
346        if (m_pPowerModule) {
347            if (m_pPowerModule->powerHint) {
348                m_pPowerModule->powerHint(m_pPowerModule, POWER_HINT_VIDEO_ENCODE,
349                        (void *)"state=0");
350            }
351        }
352    }
353#endif
354
355    return rc;
356}
357
358/*===========================================================================
359 * FUNCTION   : initialize
360 *
361 * DESCRIPTION: Initialize frameworks callback functions
362 *
363 * PARAMETERS :
364 *   @callback_ops : callback function to frameworks
365 *
366 * RETURN     :
367 *
368 *==========================================================================*/
369int QCamera3HardwareInterface::initialize(
370        const struct camera3_callback_ops *callback_ops)
371{
372    int rc;
373
374    pthread_mutex_lock(&mMutex);
375
376    rc = initParameters();
377    if (rc < 0) {
378        ALOGE("%s: initParamters failed %d", __func__, rc);
379       goto err1;
380    }
381    mCallbackOps = callback_ops;
382
383    pthread_mutex_unlock(&mMutex);
384    mCameraInitialized = true;
385    return 0;
386
387err1:
388    pthread_mutex_unlock(&mMutex);
389    return rc;
390}
391
392/*===========================================================================
393 * FUNCTION   : configureStreams
394 *
395 * DESCRIPTION: Reset HAL camera device processing pipeline and set up new input
396 *              and output streams.
397 *
398 * PARAMETERS :
399 *   @stream_list : streams to be configured
400 *
401 * RETURN     :
402 *
403 *==========================================================================*/
404int QCamera3HardwareInterface::configureStreams(
405        camera3_stream_configuration_t *streamList)
406{
407    int rc = 0;
408    pthread_mutex_lock(&mMutex);
409
410    // Sanity check stream_list
411    if (streamList == NULL) {
412        ALOGE("%s: NULL stream configuration", __func__);
413        pthread_mutex_unlock(&mMutex);
414        return BAD_VALUE;
415    }
416
417    if (streamList->streams == NULL) {
418        ALOGE("%s: NULL stream list", __func__);
419        pthread_mutex_unlock(&mMutex);
420        return BAD_VALUE;
421    }
422
423    if (streamList->num_streams < 1) {
424        ALOGE("%s: Bad number of streams requested: %d", __func__,
425                streamList->num_streams);
426        pthread_mutex_unlock(&mMutex);
427        return BAD_VALUE;
428    }
429
430    camera3_stream_t *inputStream = NULL;
431    /* first invalidate all the steams in the mStreamList
432     * if they appear again, they will be validated */
433    for (List<stream_info_t*>::iterator it=mStreamInfo.begin();
434            it != mStreamInfo.end(); it++) {
435        QCamera3Channel *channel = (QCamera3Channel*)(*it)->stream->priv;
436        channel->stop();
437        (*it)->status = INVALID;
438    }
439
440
441    for (size_t i = 0; i < streamList->num_streams; i++) {
442        camera3_stream_t *newStream = streamList->streams[i];
443        ALOGV("%s: newStream type = %d, stream format = %d",
444                __func__, newStream->stream_type, newStream->format);
445        //if the stream is in the mStreamList validate it
446        bool stream_exists = false;
447        for (List<stream_info_t*>::iterator it=mStreamInfo.begin();
448                it != mStreamInfo.end(); it++) {
449            if ((*it)->stream == newStream) {
450                QCamera3Channel *channel =
451                    (QCamera3Channel*)(*it)->stream->priv;
452                stream_exists = true;
453                (*it)->status = RECONFIGURE;
454                /*delete the channel object associated with the stream because
455                  we need to reconfigure*/
456                delete channel;
457                (*it)->stream->priv = NULL;
458            }
459        }
460        if (!stream_exists) {
461            //new stream
462            stream_info_t* stream_info;
463            stream_info = (stream_info_t* )malloc(sizeof(stream_info_t));
464            stream_info->stream = newStream;
465            stream_info->status = VALID;
466            stream_info->registered = 0;
467            mStreamInfo.push_back(stream_info);
468        }
469        if (newStream->stream_type == CAMERA3_STREAM_INPUT) {
470            if (inputStream != NULL) {
471                ALOGE("%s: Multiple input streams requested!", __func__);
472                pthread_mutex_unlock(&mMutex);
473                return BAD_VALUE;
474            }
475            inputStream = newStream;
476        }
477    }
478    mInputStream = inputStream;
479
480    /*clean up invalid streams*/
481    for (List<stream_info_t*>::iterator it=mStreamInfo.begin();
482            it != mStreamInfo.end();) {
483        if(((*it)->status) == INVALID){
484            QCamera3Channel *channel = (QCamera3Channel*)(*it)->stream->priv;
485            delete channel;
486            delete[] (buffer_handle_t*)(*it)->buffer_set.buffers;
487            free(*it);
488            it = mStreamInfo.erase(it);
489        } else {
490            it++;
491        }
492    }
493
494    if (mMetadataChannel) {
495        mMetadataChannel->stop();
496        delete mMetadataChannel;
497        mMetadataChannel = NULL;
498    }
499
500    //Create metadata channel and initialize it
501    mMetadataChannel = new QCamera3MetadataChannel(mCameraHandle->camera_handle,
502                    mCameraHandle->ops, captureResultCb,
503                    &gCamCapability[mCameraId]->padding_info, this);
504    if (mMetadataChannel == NULL) {
505        ALOGE("%s: failed to allocate metadata channel", __func__);
506        rc = -ENOMEM;
507        pthread_mutex_unlock(&mMutex);
508	return rc;
509    }
510    rc = mMetadataChannel->initialize();
511    if (rc < 0) {
512        ALOGE("%s: metadata channel initialization failed", __func__);
513        delete mMetadataChannel;
514        pthread_mutex_unlock(&mMutex);
515        return rc;
516    }
517
518    /* Allocate channel objects for the requested streams */
519    for (size_t i = 0; i < streamList->num_streams; i++) {
520        camera3_stream_t *newStream = streamList->streams[i];
521        if (newStream->priv == NULL) {
522            //New stream, construct channel
523            switch (newStream->stream_type) {
524            case CAMERA3_STREAM_INPUT:
525                newStream->usage = GRALLOC_USAGE_HW_CAMERA_READ;
526                break;
527            case CAMERA3_STREAM_BIDIRECTIONAL:
528                newStream->usage = GRALLOC_USAGE_HW_CAMERA_READ |
529                    GRALLOC_USAGE_HW_CAMERA_WRITE;
530                break;
531            case CAMERA3_STREAM_OUTPUT:
532                newStream->usage = GRALLOC_USAGE_HW_CAMERA_WRITE;
533                break;
534            default:
535                ALOGE("%s: Invalid stream_type %d", __func__, newStream->stream_type);
536                break;
537            }
538
539            if (newStream->stream_type == CAMERA3_STREAM_OUTPUT ||
540                    newStream->stream_type == CAMERA3_STREAM_BIDIRECTIONAL) {
541                QCamera3Channel *channel;
542                switch (newStream->format) {
543                case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED:
544                case HAL_PIXEL_FORMAT_YCbCr_420_888:
545                    newStream->max_buffers = QCamera3RegularChannel::kMaxBuffers;
546                    channel = new QCamera3RegularChannel(mCameraHandle->camera_handle,
547                            mCameraHandle->ops, captureResultCb,
548                            &gCamCapability[mCameraId]->padding_info, this, newStream);
549                    if (channel == NULL) {
550                        ALOGE("%s: allocation of channel failed", __func__);
551                        pthread_mutex_unlock(&mMutex);
552                        return -ENOMEM;
553                    }
554
555                    newStream->priv = channel;
556                    break;
557                case HAL_PIXEL_FORMAT_BLOB:
558                    newStream->max_buffers = QCamera3PicChannel::kMaxBuffers;
559                    channel = new QCamera3PicChannel(mCameraHandle->camera_handle,
560                            mCameraHandle->ops, captureResultCb,
561                            &gCamCapability[mCameraId]->padding_info, this, newStream);
562                    if (channel == NULL) {
563                        ALOGE("%s: allocation of channel failed", __func__);
564                        pthread_mutex_unlock(&mMutex);
565                        return -ENOMEM;
566                    }
567                    newStream->priv = channel;
568                    break;
569
570                //TODO: Add support for app consumed format?
571                default:
572                    ALOGE("%s: not a supported format 0x%x", __func__, newStream->format);
573                    break;
574                }
575            }
576        } else {
577            // Channel already exists for this stream
578            // Do nothing for now
579        }
580    }
581    /*For the streams to be reconfigured we need to register the buffers
582      since the framework wont*/
583    for (List<stream_info_t *>::iterator it = mStreamInfo.begin();
584            it != mStreamInfo.end(); it++) {
585        if ((*it)->status == RECONFIGURE) {
586            QCamera3Channel *channel = (QCamera3Channel *)(*it)->stream->priv;
587            /*only register buffers for streams that have already been
588              registered*/
589            if ((*it)->registered) {
590                rc = channel->registerBuffers((*it)->buffer_set.num_buffers,
591                        (*it)->buffer_set.buffers);
592                if (rc != NO_ERROR) {
593                    ALOGE("%s: Failed to register the buffers of old stream,\
594                            rc = %d", __func__, rc);
595                }
596                ALOGV("%s: channel %p has %d buffers",
597                        __func__, channel, (*it)->buffer_set.num_buffers);
598            }
599        }
600
601        ssize_t index = mPendingBuffersMap.indexOfKey((*it)->stream);
602        if (index == NAME_NOT_FOUND) {
603            mPendingBuffersMap.add((*it)->stream, 0);
604        } else {
605            mPendingBuffersMap.editValueAt(index) = 0;
606        }
607    }
608
609    /* Initialize mPendingRequestInfo and mPendnigBuffersMap */
610    mPendingRequestsList.clear();
611
612    //settings/parameters don't carry over for new configureStreams
613    memset(mParameters, 0, sizeof(parm_buffer_t));
614    mFirstRequest = true;
615
616    pthread_mutex_unlock(&mMutex);
617    return rc;
618}
619
620/*===========================================================================
621 * FUNCTION   : validateCaptureRequest
622 *
623 * DESCRIPTION: validate a capture request from camera service
624 *
625 * PARAMETERS :
626 *   @request : request from framework to process
627 *
628 * RETURN     :
629 *
630 *==========================================================================*/
631int QCamera3HardwareInterface::validateCaptureRequest(
632                    camera3_capture_request_t *request)
633{
634    ssize_t idx = 0;
635    const camera3_stream_buffer_t *b;
636    CameraMetadata meta;
637
638    /* Sanity check the request */
639    if (request == NULL) {
640        ALOGE("%s: NULL capture request", __func__);
641        return BAD_VALUE;
642    }
643
644    uint32_t frameNumber = request->frame_number;
645    if (request->input_buffer != NULL &&
646            request->input_buffer->stream != mInputStream) {
647        ALOGE("%s: Request %d: Input buffer not from input stream!",
648                __FUNCTION__, frameNumber);
649        return BAD_VALUE;
650    }
651    if (request->num_output_buffers < 1 || request->output_buffers == NULL) {
652        ALOGE("%s: Request %d: No output buffers provided!",
653                __FUNCTION__, frameNumber);
654        return BAD_VALUE;
655    }
656    if (request->input_buffer != NULL) {
657        //TODO
658        ALOGE("%s: Not supporting input buffer yet", __func__);
659        return BAD_VALUE;
660    }
661
662    // Validate all buffers
663    b = request->output_buffers;
664    do {
665        QCamera3Channel *channel =
666                static_cast<QCamera3Channel*>(b->stream->priv);
667        if (channel == NULL) {
668            ALOGE("%s: Request %d: Buffer %d: Unconfigured stream!",
669                    __func__, frameNumber, idx);
670            return BAD_VALUE;
671        }
672        if (b->status != CAMERA3_BUFFER_STATUS_OK) {
673            ALOGE("%s: Request %d: Buffer %d: Status not OK!",
674                    __func__, frameNumber, idx);
675            return BAD_VALUE;
676        }
677        if (b->release_fence != -1) {
678            ALOGE("%s: Request %d: Buffer %d: Has a release fence!",
679                    __func__, frameNumber, idx);
680            return BAD_VALUE;
681        }
682        if (b->buffer == NULL) {
683            ALOGE("%s: Request %d: Buffer %d: NULL buffer handle!",
684                    __func__, frameNumber, idx);
685            return BAD_VALUE;
686        }
687        idx++;
688        b = request->output_buffers + idx;
689    } while (idx < (ssize_t)request->num_output_buffers);
690
691    return NO_ERROR;
692}
693
694/*===========================================================================
695 * FUNCTION   : registerStreamBuffers
696 *
697 * DESCRIPTION: Register buffers for a given stream with the HAL device.
698 *
699 * PARAMETERS :
700 *   @stream_list : streams to be configured
701 *
702 * RETURN     :
703 *
704 *==========================================================================*/
705int QCamera3HardwareInterface::registerStreamBuffers(
706        const camera3_stream_buffer_set_t *buffer_set)
707{
708    int rc = 0;
709
710    pthread_mutex_lock(&mMutex);
711
712    if (buffer_set == NULL) {
713        ALOGE("%s: Invalid buffer_set parameter.", __func__);
714        pthread_mutex_unlock(&mMutex);
715        return -EINVAL;
716    }
717    if (buffer_set->stream == NULL) {
718        ALOGE("%s: Invalid stream parameter.", __func__);
719        pthread_mutex_unlock(&mMutex);
720        return -EINVAL;
721    }
722    if (buffer_set->num_buffers < 1) {
723        ALOGE("%s: Invalid num_buffers %d.", __func__, buffer_set->num_buffers);
724        pthread_mutex_unlock(&mMutex);
725        return -EINVAL;
726    }
727    if (buffer_set->buffers == NULL) {
728        ALOGE("%s: Invalid buffers parameter.", __func__);
729        pthread_mutex_unlock(&mMutex);
730        return -EINVAL;
731    }
732
733    camera3_stream_t *stream = buffer_set->stream;
734    QCamera3Channel *channel = (QCamera3Channel *)stream->priv;
735
736    //set the buffer_set in the mStreamInfo array
737    for (List<stream_info_t *>::iterator it = mStreamInfo.begin();
738            it != mStreamInfo.end(); it++) {
739        if ((*it)->stream == stream) {
740            uint32_t numBuffers = buffer_set->num_buffers;
741            (*it)->buffer_set.stream = buffer_set->stream;
742            (*it)->buffer_set.num_buffers = numBuffers;
743            (*it)->buffer_set.buffers = new buffer_handle_t*[numBuffers];
744            if ((*it)->buffer_set.buffers == NULL) {
745                ALOGE("%s: Failed to allocate buffer_handle_t*", __func__);
746                pthread_mutex_unlock(&mMutex);
747                return -ENOMEM;
748            }
749            for (size_t j = 0; j < numBuffers; j++){
750                (*it)->buffer_set.buffers[j] = buffer_set->buffers[j];
751            }
752            (*it)->registered = 1;
753        }
754    }
755
756    if (stream->stream_type != CAMERA3_STREAM_OUTPUT) {
757        ALOGE("%s: not yet support non output type stream", __func__);
758        pthread_mutex_unlock(&mMutex);
759        return -EINVAL;
760    }
761    rc = channel->registerBuffers(buffer_set->num_buffers, buffer_set->buffers);
762    if (rc < 0) {
763        ALOGE("%s: registerBUffers for stream %p failed", __func__, stream);
764        pthread_mutex_unlock(&mMutex);
765        return -ENODEV;
766    }
767
768    pthread_mutex_unlock(&mMutex);
769    return NO_ERROR;
770}
771
772/*===========================================================================
773 * FUNCTION   : processCaptureRequest
774 *
775 * DESCRIPTION: process a capture request from camera service
776 *
777 * PARAMETERS :
778 *   @request : request from framework to process
779 *
780 * RETURN     :
781 *
782 *==========================================================================*/
783int QCamera3HardwareInterface::processCaptureRequest(
784                    camera3_capture_request_t *request)
785{
786    int rc = NO_ERROR;
787    int32_t request_id;
788    CameraMetadata meta;
789
790    pthread_mutex_lock(&mMutex);
791
792    rc = validateCaptureRequest(request);
793    if (rc != NO_ERROR) {
794        ALOGE("%s: incoming request is not valid", __func__);
795        pthread_mutex_unlock(&mMutex);
796        return rc;
797    }
798
799    uint32_t frameNumber = request->frame_number;
800
801    rc = setFrameParameters(request->frame_number, request->settings);
802    if (rc < 0) {
803        ALOGE("%s: fail to set frame parameters", __func__);
804        pthread_mutex_unlock(&mMutex);
805        return rc;
806    }
807
808    meta = request->settings;
809    if (meta.exists(ANDROID_REQUEST_ID)) {
810        request_id = meta.find(ANDROID_REQUEST_ID).data.i32[0];
811        mCurrentRequestId = request_id;
812        ALOGV("%s: Received request with id: %d",__func__, request_id);
813    } else if (mFirstRequest || mCurrentRequestId == -1){
814        ALOGE("%s: Unable to find request id field, \
815                & no previous id available", __func__);
816        return NAME_NOT_FOUND;
817    } else {
818        ALOGV("%s: Re-using old request id", __func__);
819        request_id = mCurrentRequestId;
820    }
821
822
823    ALOGV("%s: %d, num_output_buffers = %d", __func__, __LINE__,
824                                    request->num_output_buffers);
825    // Acquire all request buffers first
826    for (size_t i = 0; i < request->num_output_buffers; i++) {
827        const camera3_stream_buffer_t& output = request->output_buffers[i];
828        sp<Fence> acquireFence = new Fence(output.acquire_fence);
829
830        if (output.stream->format == HAL_PIXEL_FORMAT_BLOB) {
831        //Call function to store local copy of jpeg data for encode params.
832            rc = getJpegSettings(request->settings);
833            if (rc < 0) {
834                ALOGE("%s: failed to get jpeg parameters", __func__);
835                pthread_mutex_unlock(&mMutex);
836                return rc;
837            }
838        }
839
840        rc = acquireFence->wait(Fence::TIMEOUT_NEVER);
841        if (rc != OK) {
842            ALOGE("%s: fence wait failed %d", __func__, rc);
843            pthread_mutex_unlock(&mMutex);
844            return rc;
845        }
846    }
847
848    /* Update pending request list and pending buffers map */
849    pthread_mutex_lock(&mRequestLock);
850    PendingRequestInfo pendingRequest;
851    pendingRequest.frame_number = frameNumber;
852    pendingRequest.num_buffers = request->num_output_buffers;
853    pendingRequest.request_id = request_id;
854
855    for (size_t i = 0; i < request->num_output_buffers; i++) {
856        RequestedBufferInfo requestedBuf;
857        requestedBuf.stream = request->output_buffers[i].stream;
858        requestedBuf.buffer = NULL;
859        pendingRequest.buffers.push_back(requestedBuf);
860
861        mPendingBuffersMap.editValueFor(requestedBuf.stream)++;
862    }
863    mPendingRequestsList.push_back(pendingRequest);
864    pthread_mutex_unlock(&mRequestLock);
865
866    // Notify metadata channel we receive a request
867    mMetadataChannel->request(NULL, frameNumber);
868
869    // Call request on other streams
870    for (size_t i = 0; i < request->num_output_buffers; i++) {
871        const camera3_stream_buffer_t& output = request->output_buffers[i];
872        QCamera3Channel *channel = (QCamera3Channel *)output.stream->priv;
873
874        if (channel == NULL) {
875            ALOGE("%s: invalid channel pointer for stream", __func__);
876            continue;
877        }
878
879        if (output.stream->format == HAL_PIXEL_FORMAT_BLOB) {
880            rc = channel->request(output.buffer, frameNumber, mJpegSettings);
881        } else {
882            ALOGV("%s: %d, request with buffer %p, frame_number %d", __func__,
883                __LINE__, output.buffer, frameNumber);
884            rc = channel->request(output.buffer, frameNumber);
885        }
886        if (rc < 0)
887            ALOGE("%s: request failed", __func__);
888    }
889
890    mFirstRequest = false;
891
892    //Block on conditional variable
893    pthread_mutex_lock(&mRequestLock);
894    mPendingRequest = 1;
895    while (mPendingRequest == 1) {
896        pthread_cond_wait(&mRequestCond, &mRequestLock);
897    }
898    pthread_mutex_unlock(&mRequestLock);
899
900    pthread_mutex_unlock(&mMutex);
901    return rc;
902}
903
904/*===========================================================================
905 * FUNCTION   : getMetadataVendorTagOps
906 *
907 * DESCRIPTION:
908 *
909 * PARAMETERS :
910 *
911 *
912 * RETURN     :
913 *==========================================================================*/
914void QCamera3HardwareInterface::getMetadataVendorTagOps(
915                    vendor_tag_query_ops_t* /*ops*/)
916{
917    /* Enable locks when we eventually add Vendor Tags */
918    /*
919    pthread_mutex_lock(&mMutex);
920
921    pthread_mutex_unlock(&mMutex);
922    */
923    return;
924}
925
926/*===========================================================================
927 * FUNCTION   : dump
928 *
929 * DESCRIPTION:
930 *
931 * PARAMETERS :
932 *
933 *
934 * RETURN     :
935 *==========================================================================*/
936void QCamera3HardwareInterface::dump(int /*fd*/)
937{
938    /*Enable lock when we implement this function*/
939    /*
940    pthread_mutex_lock(&mMutex);
941
942    pthread_mutex_unlock(&mMutex);
943    */
944    return;
945}
946
947/*===========================================================================
948 * FUNCTION   : captureResultCb
949 *
950 * DESCRIPTION: Callback handler for all capture result
951 *              (streams, as well as metadata)
952 *
953 * PARAMETERS :
954 *   @metadata : metadata information
955 *   @buffer   : actual gralloc buffer to be returned to frameworks.
956 *               NULL if metadata.
957 *
958 * RETURN     : NONE
959 *==========================================================================*/
960void QCamera3HardwareInterface::captureResultCb(mm_camera_super_buf_t *metadata_buf,
961                camera3_stream_buffer_t *buffer, uint32_t frame_number)
962{
963    pthread_mutex_lock(&mRequestLock);
964
965    if (metadata_buf) {
966        metadata_buffer_t *metadata = (metadata_buffer_t *)metadata_buf->bufs[0]->buffer;
967        int32_t frame_number_valid = *(int32_t *)
968            POINTER_OF(CAM_INTF_META_FRAME_NUMBER_VALID, metadata);
969        uint32_t frame_number = *(uint32_t *)
970            POINTER_OF(CAM_INTF_META_FRAME_NUMBER, metadata);
971        const struct timeval *tv = (const struct timeval *)
972            POINTER_OF(CAM_INTF_META_SENSOR_TIMESTAMP, metadata);
973        nsecs_t capture_time = (nsecs_t)tv->tv_sec * NSEC_PER_SEC +
974            tv->tv_usec * NSEC_PER_USEC;
975
976        if (!frame_number_valid) {
977            ALOGV("%s: Not a valid frame number, used as SOF only", __func__);
978            mMetadataChannel->bufDone(metadata_buf);
979            goto done_metadata;
980        }
981        ALOGV("%s: valid frame_number = %d, capture_time = %lld", __func__,
982                frame_number, capture_time);
983
984        // Go through the pending requests info and send shutter/results to frameworks
985        for (List<PendingRequestInfo>::iterator i = mPendingRequestsList.begin();
986                i != mPendingRequestsList.end() && i->frame_number <= frame_number;) {
987            camera3_capture_result_t result;
988            camera3_notify_msg_t notify_msg;
989            ALOGV("%s: frame_number in the list is %d", __func__, i->frame_number);
990
991            // Flush out all entries with less or equal frame numbers.
992
993            //TODO: Make sure shutter timestamp really reflects shutter timestamp.
994            //Right now it's the same as metadata timestamp
995
996            //TODO: When there is metadata drop, how do we derive the timestamp of
997            //dropped frames? For now, we fake the dropped timestamp by substracting
998            //from the reported timestamp
999            nsecs_t current_capture_time = capture_time -
1000                (frame_number - i->frame_number) * NSEC_PER_33MSEC;
1001
1002            // Send shutter notify to frameworks
1003            notify_msg.type = CAMERA3_MSG_SHUTTER;
1004            notify_msg.message.shutter.frame_number = i->frame_number;
1005            notify_msg.message.shutter.timestamp = current_capture_time;
1006            mCallbackOps->notify(mCallbackOps, &notify_msg);
1007            ALOGV("%s: notify frame_number = %d, capture_time = %lld", __func__,
1008                    i->frame_number, capture_time);
1009
1010            // Send empty metadata with already filled buffers for dropped metadata
1011            // and send valid metadata with already filled buffers for current metadata
1012            if (i->frame_number < frame_number) {
1013                CameraMetadata dummyMetadata;
1014                dummyMetadata.update(ANDROID_SENSOR_TIMESTAMP,
1015                        &current_capture_time, 1);
1016                dummyMetadata.update(ANDROID_REQUEST_ID,
1017                        &(i->request_id), 1);
1018                result.result = dummyMetadata.release();
1019            } else {
1020                result.result = translateCbMetadataToResultMetadata(metadata,
1021                        current_capture_time, i->request_id);
1022                // Return metadata buffer
1023                mMetadataChannel->bufDone(metadata_buf);
1024            }
1025            if (!result.result) {
1026                ALOGE("%s: metadata is NULL", __func__);
1027            }
1028            result.frame_number = i->frame_number;
1029            result.num_output_buffers = 0;
1030            result.output_buffers = NULL;
1031            for (List<RequestedBufferInfo>::iterator j = i->buffers.begin();
1032                    j != i->buffers.end(); j++) {
1033                if (j->buffer) {
1034                    result.num_output_buffers++;
1035                }
1036            }
1037
1038            if (result.num_output_buffers > 0) {
1039                camera3_stream_buffer_t *result_buffers =
1040                    new camera3_stream_buffer_t[result.num_output_buffers];
1041                if (!result_buffers) {
1042                    ALOGE("%s: Fatal error: out of memory", __func__);
1043                }
1044                size_t result_buffers_idx = 0;
1045                for (List<RequestedBufferInfo>::iterator j = i->buffers.begin();
1046                        j != i->buffers.end(); j++) {
1047                    if (j->buffer) {
1048                        result_buffers[result_buffers_idx++] = *(j->buffer);
1049                        free(j->buffer);
1050                        j->buffer = NULL;
1051                        mPendingBuffersMap.editValueFor(j->stream)--;
1052                    }
1053                }
1054                result.output_buffers = result_buffers;
1055
1056                mCallbackOps->process_capture_result(mCallbackOps, &result);
1057                ALOGV("%s: meta frame_number = %d, capture_time = %lld",
1058                        __func__, result.frame_number, current_capture_time);
1059                free_camera_metadata((camera_metadata_t *)result.result);
1060                delete[] result_buffers;
1061            } else {
1062                mCallbackOps->process_capture_result(mCallbackOps, &result);
1063                ALOGV("%s: meta frame_number = %d, capture_time = %lld",
1064                        __func__, result.frame_number, current_capture_time);
1065                free_camera_metadata((camera_metadata_t *)result.result);
1066            }
1067            // erase the element from the list
1068            i = mPendingRequestsList.erase(i);
1069        }
1070
1071
1072done_metadata:
1073        bool max_buffers_dequeued = false;
1074        for (size_t i = 0; i < mPendingBuffersMap.size(); i++) {
1075            const camera3_stream_t *stream = mPendingBuffersMap.keyAt(i);
1076            uint32_t queued_buffers = mPendingBuffersMap.valueAt(i);
1077            if (queued_buffers == stream->max_buffers) {
1078                max_buffers_dequeued = true;
1079                break;
1080            }
1081        }
1082        if (!max_buffers_dequeued) {
1083            // Unblock process_capture_request
1084            mPendingRequest = 0;
1085            pthread_cond_signal(&mRequestCond);
1086        }
1087    } else {
1088        // If the frame number doesn't exist in the pending request list,
1089        // directly send the buffer to the frameworks, and update pending buffers map
1090        // Otherwise, book-keep the buffer.
1091        List<PendingRequestInfo>::iterator i = mPendingRequestsList.begin();
1092        while (i != mPendingRequestsList.end() && i->frame_number != frame_number)
1093            i++;
1094        if (i == mPendingRequestsList.end()) {
1095            // Verify all pending requests frame_numbers are greater
1096            for (List<PendingRequestInfo>::iterator j = mPendingRequestsList.begin();
1097                    j != mPendingRequestsList.end(); j++) {
1098                if (j->frame_number < frame_number) {
1099                    ALOGE("%s: Error: pending frame number %d is smaller than %d",
1100                            __func__, j->frame_number, frame_number);
1101                }
1102            }
1103            camera3_capture_result_t result;
1104            result.result = NULL;
1105            result.frame_number = frame_number;
1106            result.num_output_buffers = 1;
1107            result.output_buffers = buffer;
1108            ALOGV("%s: result frame_number = %d, buffer = %p",
1109                    __func__, frame_number, buffer);
1110            mPendingBuffersMap.editValueFor(buffer->stream)--;
1111            mCallbackOps->process_capture_result(mCallbackOps, &result);
1112        } else {
1113            for (List<RequestedBufferInfo>::iterator j = i->buffers.begin();
1114                    j != i->buffers.end(); j++) {
1115                if (j->stream == buffer->stream) {
1116                    if (j->buffer != NULL) {
1117                        ALOGE("%s: Error: buffer is already set", __func__);
1118                    } else {
1119                        j->buffer = (camera3_stream_buffer_t *)malloc(
1120                                sizeof(camera3_stream_buffer_t));
1121                        *(j->buffer) = *buffer;
1122                        ALOGV("%s: cache buffer %p at result frame_number %d",
1123                                __func__, buffer, frame_number);
1124                    }
1125                }
1126            }
1127        }
1128    }
1129
1130    pthread_mutex_unlock(&mRequestLock);
1131    return;
1132}
1133
1134/*===========================================================================
1135 * FUNCTION   : translateCbMetadataToResultMetadata
1136 *
1137 * DESCRIPTION:
1138 *
1139 * PARAMETERS :
1140 *   @metadata : metadata information from callback
1141 *
1142 * RETURN     : camera_metadata_t*
1143 *              metadata in a format specified by fwk
1144 *==========================================================================*/
1145camera_metadata_t*
1146QCamera3HardwareInterface::translateCbMetadataToResultMetadata
1147                                (metadata_buffer_t *metadata, nsecs_t timestamp,
1148                                 int32_t request_id)
1149{
1150    CameraMetadata camMetadata;
1151    camera_metadata_t* resultMetadata;
1152
1153    camMetadata.update(ANDROID_SENSOR_TIMESTAMP, &timestamp, 1);
1154    camMetadata.update(ANDROID_REQUEST_ID, &request_id, 1);
1155
1156    /*CAM_INTF_META_HISTOGRAM - TODO*/
1157    /*cam_hist_stats_t  *histogram =
1158      (cam_hist_stats_t *)POINTER_OF(CAM_INTF_META_HISTOGRAM,
1159      metadata);*/
1160
1161    /*face detection*/
1162    cam_face_detection_data_t *faceDetectionInfo =(cam_face_detection_data_t *)
1163        POINTER_OF(CAM_INTF_META_FACE_DETECTION, metadata);
1164    uint8_t numFaces = faceDetectionInfo->num_faces_detected;
1165    int32_t faceIds[numFaces];
1166    uint8_t faceScores[numFaces];
1167    int32_t faceRectangles[numFaces * 4];
1168    int32_t faceLandmarks[numFaces * 6];
1169    int j = 0, k = 0;
1170    for (int i = 0; i < numFaces; i++) {
1171        faceIds[i] = faceDetectionInfo->faces[i].face_id;
1172        faceScores[i] = faceDetectionInfo->faces[i].score;
1173        convertToRegions(faceDetectionInfo->faces[i].face_boundary,
1174                faceRectangles+j, -1);
1175        convertLandmarks(faceDetectionInfo->faces[i], faceLandmarks+k);
1176        j+= 4;
1177        k+= 6;
1178    }
1179    if (numFaces > 0) {
1180        camMetadata.update(ANDROID_STATISTICS_FACE_IDS, faceIds, numFaces);
1181        camMetadata.update(ANDROID_STATISTICS_FACE_SCORES, faceScores, numFaces);
1182        camMetadata.update(ANDROID_STATISTICS_FACE_RECTANGLES,
1183            faceRectangles, numFaces*4);
1184        camMetadata.update(ANDROID_STATISTICS_FACE_LANDMARKS,
1185            faceLandmarks, numFaces*6);
1186    }
1187
1188    uint8_t  *color_correct_mode =
1189        (uint8_t *)POINTER_OF(CAM_INTF_META_COLOR_CORRECT_MODE, metadata);
1190    camMetadata.update(ANDROID_COLOR_CORRECTION_MODE, color_correct_mode, 1);
1191
1192    int32_t  *ae_precapture_id =
1193        (int32_t *)POINTER_OF(CAM_INTF_META_AEC_PRECAPTURE_ID, metadata);
1194    camMetadata.update(ANDROID_CONTROL_AE_PRECAPTURE_ID, ae_precapture_id, 1);
1195
1196    /*aec regions*/
1197    cam_area_t  *hAeRegions =
1198        (cam_area_t *)POINTER_OF(CAM_INTF_META_AEC_ROI, metadata);
1199    int32_t aeRegions[5];
1200    convertToRegions(hAeRegions->rect, aeRegions, hAeRegions->weight);
1201    camMetadata.update(ANDROID_CONTROL_AE_REGIONS, aeRegions, 5);
1202
1203    uint8_t  *ae_state =
1204        (uint8_t *)POINTER_OF(CAM_INTF_META_AEC_STATE, metadata);
1205    camMetadata.update(ANDROID_CONTROL_AE_STATE, ae_state, 1);
1206
1207    uint8_t  *focusMode =
1208        (uint8_t *)POINTER_OF(CAM_INTF_PARM_FOCUS_MODE, metadata);
1209    camMetadata.update(ANDROID_CONTROL_AF_MODE, focusMode, 1);
1210
1211    /*af regions*/
1212    cam_area_t  *hAfRegions =
1213        (cam_area_t *)POINTER_OF(CAM_INTF_META_AF_ROI, metadata);
1214    int32_t afRegions[5];
1215    convertToRegions(hAfRegions->rect, afRegions, hAfRegions->weight);
1216    camMetadata.update(ANDROID_CONTROL_AF_REGIONS, afRegions, 5);
1217
1218    uint8_t  *afState = (uint8_t *)POINTER_OF(CAM_INTF_META_AF_STATE, metadata);
1219    camMetadata.update(ANDROID_CONTROL_AF_STATE, afState, 1);
1220
1221    int32_t  *afTriggerId =
1222        (int32_t *)POINTER_OF(CAM_INTF_META_AF_TRIGGER_ID, metadata);
1223    camMetadata.update(ANDROID_CONTROL_AF_TRIGGER_ID, afTriggerId, 1);
1224
1225    uint8_t  *whiteBalance =
1226        (uint8_t *)POINTER_OF(CAM_INTF_PARM_WHITE_BALANCE, metadata);
1227    camMetadata.update(ANDROID_CONTROL_AWB_MODE, whiteBalance, 1);
1228
1229    /*awb regions*/
1230    cam_area_t  *hAwbRegions =
1231        (cam_area_t *)POINTER_OF(CAM_INTF_META_AWB_REGIONS, metadata);
1232    int32_t awbRegions[5];
1233    convertToRegions(hAwbRegions->rect, awbRegions, hAwbRegions->weight);
1234    camMetadata.update(ANDROID_CONTROL_AWB_REGIONS, awbRegions, 5);
1235
1236    uint8_t  *whiteBalanceState =
1237        (uint8_t *)POINTER_OF(CAM_INTF_META_AWB_STATE, metadata);
1238    camMetadata.update(ANDROID_CONTROL_AWB_STATE, whiteBalanceState, 1);
1239
1240    uint8_t  *mode = (uint8_t *)POINTER_OF(CAM_INTF_META_MODE, metadata);
1241    camMetadata.update(ANDROID_CONTROL_MODE, mode, 1);
1242
1243    uint8_t  *edgeMode = (uint8_t *)POINTER_OF(CAM_INTF_META_EDGE, metadata);
1244    camMetadata.update(ANDROID_EDGE_MODE, edgeMode, 1);
1245
1246    uint8_t  *flashPower =
1247        (uint8_t *)POINTER_OF(CAM_INTF_META_FLASH_POWER, metadata);
1248    camMetadata.update(ANDROID_FLASH_FIRING_POWER, flashPower, 1);
1249
1250    int64_t  *flashFiringTime =
1251        (int64_t *)POINTER_OF(CAM_INTF_META_FLASH_FIRING_TIME, metadata);
1252    camMetadata.update(ANDROID_FLASH_FIRING_TIME, flashFiringTime, 1);
1253
1254    /*int32_t  *ledMode =
1255      (int32_t *)POINTER_OF(CAM_INTF_PARM_LED_MODE, metadata);
1256      camMetadata.update(ANDROID_FLASH_FIRING_TIME, ledMode, 1);*/
1257
1258    uint8_t  *flashState =
1259        (uint8_t *)POINTER_OF(CAM_INTF_META_FLASH_STATE, metadata);
1260    camMetadata.update(ANDROID_FLASH_STATE, flashState, 1);
1261
1262    uint8_t  *hotPixelMode =
1263        (uint8_t *)POINTER_OF(CAM_INTF_META_HOTPIXEL_MODE, metadata);
1264    camMetadata.update(ANDROID_HOT_PIXEL_MODE, hotPixelMode, 1);
1265
1266    float  *lensAperture =
1267        (float *)POINTER_OF(CAM_INTF_META_LENS_APERTURE, metadata);
1268    camMetadata.update(ANDROID_LENS_APERTURE , lensAperture, 1);
1269
1270    float  *filterDensity =
1271        (float *)POINTER_OF(CAM_INTF_META_LENS_FILTERDENSITY, metadata);
1272    camMetadata.update(ANDROID_LENS_FILTER_DENSITY , filterDensity, 1);
1273
1274    float  *focalLength =
1275        (float *)POINTER_OF(CAM_INTF_META_LENS_FOCAL_LENGTH, metadata);
1276    camMetadata.update(ANDROID_LENS_FOCAL_LENGTH, focalLength, 1);
1277
1278    float  *focusDistance =
1279        (float *)POINTER_OF(CAM_INTF_META_LENS_FOCUS_DISTANCE, metadata);
1280    camMetadata.update(ANDROID_LENS_FOCUS_DISTANCE , focusDistance, 1);
1281
1282    float  *focusRange =
1283        (float *)POINTER_OF(CAM_INTF_META_LENS_FOCUS_RANGE, metadata);
1284    camMetadata.update(ANDROID_LENS_FOCUS_RANGE , focusRange, 1);
1285
1286    uint8_t  *opticalStab =
1287        (uint8_t *)POINTER_OF(CAM_INTF_META_LENS_OPT_STAB_MODE, metadata);
1288    camMetadata.update(ANDROID_LENS_OPTICAL_STABILIZATION_MODE ,opticalStab, 1);
1289
1290    /*int32_t  *focusState =
1291      (int32_t *)POINTER_OF(CAM_INTF_META_LENS_FOCUS_STATE, metadata);
1292      camMetadata.update(ANDROID_LENS_STATE , focusState, 1); //check */
1293
1294    uint8_t  *noiseRedMode =
1295        (uint8_t *)POINTER_OF(CAM_INTF_META_NOISE_REDUCTION_MODE, metadata);
1296    camMetadata.update(ANDROID_NOISE_REDUCTION_MODE , noiseRedMode, 1);
1297
1298    /*CAM_INTF_META_SCALER_CROP_REGION - check size*/
1299
1300    cam_crop_region_t  *hScalerCropRegion =(cam_crop_region_t *)
1301        POINTER_OF(CAM_INTF_META_SCALER_CROP_REGION, metadata);
1302    int32_t scalerCropRegion[4];
1303    scalerCropRegion[0] = hScalerCropRegion->left;
1304    scalerCropRegion[1] = hScalerCropRegion->top;
1305    scalerCropRegion[2] = hScalerCropRegion->width;
1306    scalerCropRegion[3] = hScalerCropRegion->height;
1307    camMetadata.update(ANDROID_SCALER_CROP_REGION, scalerCropRegion, 4);
1308
1309    int64_t  *sensorExpTime =
1310        (int64_t *)POINTER_OF(CAM_INTF_META_SENSOR_EXPOSURE_TIME, metadata);
1311    camMetadata.update(ANDROID_SENSOR_EXPOSURE_TIME , sensorExpTime, 1);
1312
1313    int64_t  *sensorFameDuration =
1314        (int64_t *)POINTER_OF(CAM_INTF_META_SENSOR_FRAME_DURATION, metadata);
1315    camMetadata.update(ANDROID_SENSOR_FRAME_DURATION, sensorFameDuration, 1);
1316
1317    int32_t  *sensorSensitivity =
1318        (int32_t *)POINTER_OF(CAM_INTF_META_SENSOR_SENSITIVITY, metadata);
1319    mMetadataResponse.iso_speed = *sensorSensitivity;
1320    camMetadata.update(ANDROID_SENSOR_SENSITIVITY, sensorSensitivity, 1);
1321
1322    uint8_t  *shadingMode =
1323        (uint8_t *)POINTER_OF(CAM_INTF_META_SHADING_MODE, metadata);
1324    camMetadata.update(ANDROID_SHADING_MODE, shadingMode, 1);
1325
1326    uint8_t  *faceDetectMode =
1327        (uint8_t *)POINTER_OF(CAM_INTF_META_STATS_FACEDETECT_MODE, metadata);
1328    camMetadata.update(ANDROID_STATISTICS_FACE_DETECT_MODE, faceDetectMode, 1);
1329
1330    uint8_t  *histogramMode =
1331        (uint8_t *)POINTER_OF(CAM_INTF_META_STATS_HISTOGRAM_MODE, metadata);
1332    camMetadata.update(ANDROID_STATISTICS_HISTOGRAM_MODE, histogramMode, 1);
1333
1334    uint8_t  *sharpnessMapMode =
1335        (uint8_t *)POINTER_OF(CAM_INTF_META_STATS_SHARPNESS_MAP_MODE, metadata);
1336    camMetadata.update(ANDROID_STATISTICS_SHARPNESS_MAP_MODE,
1337            sharpnessMapMode, 1);
1338
1339    /*CAM_INTF_META_STATS_SHARPNESS_MAP - check size*/
1340    cam_sharpness_map_t  *sharpnessMap = (cam_sharpness_map_t *)
1341        POINTER_OF(CAM_INTF_META_STATS_SHARPNESS_MAP, metadata);
1342    camMetadata.update(ANDROID_STATISTICS_SHARPNESS_MAP,
1343            (int32_t*)sharpnessMap->sharpness,
1344            CAM_MAX_MAP_WIDTH*CAM_MAX_MAP_HEIGHT);
1345
1346    resultMetadata = camMetadata.release();
1347    return resultMetadata;
1348}
1349
1350/*===========================================================================
1351 * FUNCTION   : convertToRegions
1352 *
1353 * DESCRIPTION: helper method to convert from cam_rect_t into int32_t array
1354 *
1355 * PARAMETERS :
1356 *   @rect   : cam_rect_t struct to convert
1357 *   @region : int32_t destination array
1358 *   @weight : if we are converting from cam_area_t, weight is valid
1359 *             else weight = -1
1360 *
1361 *==========================================================================*/
1362void QCamera3HardwareInterface::convertToRegions(cam_rect_t rect, int32_t* region, int weight){
1363    region[0] = rect.left;
1364    region[1] = rect.top;
1365    region[2] = rect.left + rect.width;
1366    region[3] = rect.top + rect.height;
1367    if (weight > -1) {
1368        region[4] = weight;
1369    }
1370}
1371
1372/*===========================================================================
1373 * FUNCTION   : convertFromRegions
1374 *
1375 * DESCRIPTION: helper method to convert from array to cam_rect_t
1376 *
1377 * PARAMETERS :
1378 *   @rect   : cam_rect_t struct to convert
1379 *   @region : int32_t destination array
1380 *   @weight : if we are converting from cam_area_t, weight is valid
1381 *             else weight = -1
1382 *
1383 *==========================================================================*/
1384void QCamera3HardwareInterface::convertFromRegions(cam_area_t* roi,
1385                                                   const camera_metadata_t *settings,
1386                                                   uint32_t tag){
1387    CameraMetadata frame_settings;
1388    frame_settings = settings;
1389    int32_t x_min = frame_settings.find(tag).data.i32[0];
1390    int32_t y_min = frame_settings.find(tag).data.i32[1];
1391    int32_t x_max = frame_settings.find(tag).data.i32[2];
1392    int32_t y_max = frame_settings.find(tag).data.i32[3];
1393    roi->weight = frame_settings.find(tag).data.i32[4];
1394    roi->rect.left = x_min;
1395    roi->rect.top = y_min;
1396    roi->rect.width = x_max - x_min;
1397    roi->rect.height = y_max - y_min;
1398}
1399
1400/*===========================================================================
1401 * FUNCTION   : resetIfNeededROI
1402 *
1403 * DESCRIPTION: helper method to reset the roi if it is greater than scaler
1404 *              crop region
1405 *
1406 * PARAMETERS :
1407 *   @roi       : cam_area_t struct to resize
1408 *   @scalerCropRegion : cam_crop_region_t region to compare against
1409 *
1410 *
1411 *==========================================================================*/
1412bool QCamera3HardwareInterface::resetIfNeededROI(cam_area_t* roi,
1413                                                 const cam_crop_region_t* scalerCropRegion)
1414{
1415    int32_t roi_x_max = roi->rect.width + roi->rect.left;
1416    int32_t roi_y_max = roi->rect.height + roi->rect.top;
1417    int32_t crop_x_max = scalerCropRegion->width + scalerCropRegion->top;
1418    int32_t crop_y_max = scalerCropRegion->height + scalerCropRegion->left;
1419    if ((roi_x_max < scalerCropRegion->left) ||
1420        (roi_y_max < scalerCropRegion->top)  ||
1421        (roi->rect.left > crop_x_max) ||
1422        (roi->rect.top > crop_y_max)){
1423        return false;
1424    }
1425    if (roi->rect.left < scalerCropRegion->left) {
1426        roi->rect.left = scalerCropRegion->left;
1427    }
1428    if (roi->rect.top < scalerCropRegion->top) {
1429        roi->rect.top = scalerCropRegion->top;
1430    }
1431    if (roi_x_max > crop_x_max) {
1432        roi_x_max = crop_x_max;
1433    }
1434    if (roi_y_max > crop_y_max) {
1435        roi_y_max = crop_y_max;
1436    }
1437    roi->rect.width = roi_x_max - roi->rect.left;
1438    roi->rect.height = roi_y_max - roi->rect.top;
1439    return true;
1440}
1441
1442/*===========================================================================
1443 * FUNCTION   : convertLandmarks
1444 *
1445 * DESCRIPTION: helper method to extract the landmarks from face detection info
1446 *
1447 * PARAMETERS :
1448 *   @face   : cam_rect_t struct to convert
1449 *   @landmarks : int32_t destination array
1450 *
1451 *
1452 *==========================================================================*/
1453void QCamera3HardwareInterface::convertLandmarks(cam_face_detection_info_t face, int32_t* landmarks)
1454{
1455    landmarks[0] = face.left_eye_center.x;
1456    landmarks[1] = face.left_eye_center.y;
1457    landmarks[2] = face.right_eye_center.y;
1458    landmarks[3] = face.right_eye_center.y;
1459    landmarks[4] = face.mouth_center.x;
1460    landmarks[5] = face.mouth_center.y;
1461}
1462
1463#define DATA_PTR(MEM_OBJ,INDEX) MEM_OBJ->getPtr( INDEX )
1464/*===========================================================================
1465 * FUNCTION   : initCapabilities
1466 *
1467 * DESCRIPTION: initialize camera capabilities in static data struct
1468 *
1469 * PARAMETERS :
1470 *   @cameraId  : camera Id
1471 *
1472 * RETURN     : int32_t type of status
1473 *              NO_ERROR  -- success
1474 *              none-zero failure code
1475 *==========================================================================*/
1476int QCamera3HardwareInterface::initCapabilities(int cameraId)
1477{
1478    int rc = 0;
1479    mm_camera_vtbl_t *cameraHandle = NULL;
1480    QCamera3HeapMemory *capabilityHeap = NULL;
1481
1482    cameraHandle = camera_open(cameraId);
1483    if (!cameraHandle) {
1484        ALOGE("%s: camera_open failed", __func__);
1485        rc = -1;
1486        goto open_failed;
1487    }
1488
1489    capabilityHeap = new QCamera3HeapMemory();
1490    if (capabilityHeap == NULL) {
1491        ALOGE("%s: creation of capabilityHeap failed", __func__);
1492        goto heap_creation_failed;
1493    }
1494    /* Allocate memory for capability buffer */
1495    rc = capabilityHeap->allocate(1, sizeof(cam_capability_t), false);
1496    if(rc != OK) {
1497        ALOGE("%s: No memory for cappability", __func__);
1498        goto allocate_failed;
1499    }
1500
1501    /* Map memory for capability buffer */
1502    memset(DATA_PTR(capabilityHeap,0), 0, sizeof(cam_capability_t));
1503    rc = cameraHandle->ops->map_buf(cameraHandle->camera_handle,
1504                                CAM_MAPPING_BUF_TYPE_CAPABILITY,
1505                                capabilityHeap->getFd(0),
1506                                sizeof(cam_capability_t));
1507    if(rc < 0) {
1508        ALOGE("%s: failed to map capability buffer", __func__);
1509        goto map_failed;
1510    }
1511
1512    /* Query Capability */
1513    rc = cameraHandle->ops->query_capability(cameraHandle->camera_handle);
1514    if(rc < 0) {
1515        ALOGE("%s: failed to query capability",__func__);
1516        goto query_failed;
1517    }
1518    gCamCapability[cameraId] = (cam_capability_t *)malloc(sizeof(cam_capability_t));
1519    if (!gCamCapability[cameraId]) {
1520        ALOGE("%s: out of memory", __func__);
1521        goto query_failed;
1522    }
1523    memcpy(gCamCapability[cameraId], DATA_PTR(capabilityHeap,0),
1524                                        sizeof(cam_capability_t));
1525    rc = 0;
1526
1527query_failed:
1528    cameraHandle->ops->unmap_buf(cameraHandle->camera_handle,
1529                            CAM_MAPPING_BUF_TYPE_CAPABILITY);
1530map_failed:
1531    capabilityHeap->deallocate();
1532allocate_failed:
1533    delete capabilityHeap;
1534heap_creation_failed:
1535    cameraHandle->ops->close_camera(cameraHandle->camera_handle);
1536    cameraHandle = NULL;
1537open_failed:
1538    return rc;
1539}
1540
1541/*===========================================================================
1542 * FUNCTION   : initParameters
1543 *
1544 * DESCRIPTION: initialize camera parameters
1545 *
1546 * PARAMETERS :
1547 *
1548 * RETURN     : int32_t type of status
1549 *              NO_ERROR  -- success
1550 *              none-zero failure code
1551 *==========================================================================*/
1552int QCamera3HardwareInterface::initParameters()
1553{
1554    int rc = 0;
1555
1556    //Allocate Set Param Buffer
1557    mParamHeap = new QCamera3HeapMemory();
1558    rc = mParamHeap->allocate(1, sizeof(parm_buffer_t), false);
1559    if(rc != OK) {
1560        rc = NO_MEMORY;
1561        ALOGE("Failed to allocate SETPARM Heap memory");
1562        delete mParamHeap;
1563        mParamHeap = NULL;
1564        return rc;
1565    }
1566
1567    //Map memory for parameters buffer
1568    rc = mCameraHandle->ops->map_buf(mCameraHandle->camera_handle,
1569            CAM_MAPPING_BUF_TYPE_PARM_BUF,
1570            mParamHeap->getFd(0),
1571            sizeof(parm_buffer_t));
1572    if(rc < 0) {
1573        ALOGE("%s:failed to map SETPARM buffer",__func__);
1574        rc = FAILED_TRANSACTION;
1575        mParamHeap->deallocate();
1576        delete mParamHeap;
1577        mParamHeap = NULL;
1578        return rc;
1579    }
1580
1581    mParameters = (parm_buffer_t*) DATA_PTR(mParamHeap,0);
1582    return rc;
1583}
1584
1585/*===========================================================================
1586 * FUNCTION   : deinitParameters
1587 *
1588 * DESCRIPTION: de-initialize camera parameters
1589 *
1590 * PARAMETERS :
1591 *
1592 * RETURN     : NONE
1593 *==========================================================================*/
1594void QCamera3HardwareInterface::deinitParameters()
1595{
1596    mCameraHandle->ops->unmap_buf(mCameraHandle->camera_handle,
1597            CAM_MAPPING_BUF_TYPE_PARM_BUF);
1598
1599    mParamHeap->deallocate();
1600    delete mParamHeap;
1601    mParamHeap = NULL;
1602
1603    mParameters = NULL;
1604}
1605
1606/*===========================================================================
1607 * FUNCTION   : calcMaxJpegSize
1608 *
1609 * DESCRIPTION: Calculates maximum jpeg size supported by the cameraId
1610 *
1611 * PARAMETERS :
1612 *
1613 * RETURN     : max_jpeg_size
1614 *==========================================================================*/
1615int QCamera3HardwareInterface::calcMaxJpegSize()
1616{
1617    int32_t max_jpeg_size = 0;
1618    int temp_width, temp_height;
1619    for (int i = 0; i < gCamCapability[mCameraId]->picture_sizes_tbl_cnt; i++) {
1620        temp_width = gCamCapability[mCameraId]->picture_sizes_tbl[i].width;
1621        temp_height = gCamCapability[mCameraId]->picture_sizes_tbl[i].height;
1622        if (temp_width * temp_height > max_jpeg_size ) {
1623            max_jpeg_size = temp_width * temp_height;
1624        }
1625    }
1626    max_jpeg_size = max_jpeg_size * 3/2 + sizeof(camera3_jpeg_blob_t);
1627    return max_jpeg_size;
1628}
1629
1630/*===========================================================================
1631 * FUNCTION   : initStaticMetadata
1632 *
1633 * DESCRIPTION: initialize the static metadata
1634 *
1635 * PARAMETERS :
1636 *   @cameraId  : camera Id
1637 *
1638 * RETURN     : int32_t type of status
1639 *              0  -- success
1640 *              non-zero failure code
1641 *==========================================================================*/
1642int QCamera3HardwareInterface::initStaticMetadata(int cameraId)
1643{
1644    int rc = 0;
1645    CameraMetadata staticInfo;
1646    int facingBack = gCamCapability[cameraId]->position == CAM_POSITION_BACK;
1647    /*HAL 3 only*/
1648    /*staticInfo.update(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE,
1649                    &gCamCapability[cameraId]->min_focus_distance, 1); */
1650
1651    /*hard coded for now but this should come from sensor*/
1652    float min_focus_distance;
1653    if(facingBack){
1654        min_focus_distance = 10;
1655    } else {
1656        min_focus_distance = 0;
1657    }
1658    staticInfo.update(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE,
1659                    &min_focus_distance, 1);
1660
1661    staticInfo.update(ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE,
1662                    &gCamCapability[cameraId]->hyper_focal_distance, 1);
1663
1664    /*should be using focal lengths but sensor doesn't provide that info now*/
1665    staticInfo.update(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS,
1666                      &gCamCapability[cameraId]->focal_length,
1667                      1);
1668
1669    staticInfo.update(ANDROID_LENS_INFO_AVAILABLE_APERTURES,
1670                      gCamCapability[cameraId]->apertures,
1671                      gCamCapability[cameraId]->apertures_count);
1672
1673    staticInfo.update(ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES,
1674                gCamCapability[cameraId]->filter_densities,
1675                gCamCapability[cameraId]->filter_densities_count);
1676
1677
1678    staticInfo.update(ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION,
1679                      (uint8_t*)gCamCapability[cameraId]->optical_stab_modes,
1680                      gCamCapability[cameraId]->optical_stab_modes_count);
1681
1682    staticInfo.update(ANDROID_LENS_POSITION,
1683                      gCamCapability[cameraId]->lens_position,
1684                      sizeof(gCamCapability[cameraId]->lens_position)/ sizeof(float));
1685
1686    int32_t lens_shading_map_size[] = {gCamCapability[cameraId]->lens_shading_map_size.width,
1687                                                    gCamCapability[cameraId]->lens_shading_map_size.height};
1688    staticInfo.update(ANDROID_LENS_INFO_SHADING_MAP_SIZE,
1689                      lens_shading_map_size,
1690                      sizeof(lens_shading_map_size)/sizeof(int32_t));
1691
1692    int32_t geo_correction_map_size[] = {gCamCapability[cameraId]->geo_correction_map_size.width,
1693                                                      gCamCapability[cameraId]->geo_correction_map_size.height};
1694    staticInfo.update(ANDROID_LENS_INFO_GEOMETRIC_CORRECTION_MAP_SIZE,
1695            geo_correction_map_size,
1696            sizeof(geo_correction_map_size)/sizeof(int32_t));
1697
1698    staticInfo.update(ANDROID_LENS_INFO_GEOMETRIC_CORRECTION_MAP,
1699                       gCamCapability[cameraId]->geo_correction_map,
1700                       sizeof(gCamCapability[cameraId]->geo_correction_map)/sizeof(float));
1701
1702    staticInfo.update(ANDROID_SENSOR_INFO_PHYSICAL_SIZE,
1703            gCamCapability[cameraId]->sensor_physical_size, 2);
1704
1705    staticInfo.update(ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE,
1706            gCamCapability[cameraId]->exposure_time_range, 2);
1707
1708    staticInfo.update(ANDROID_SENSOR_INFO_MAX_FRAME_DURATION,
1709            &gCamCapability[cameraId]->max_frame_duration, 1);
1710
1711
1712    staticInfo.update(ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT,
1713                     (uint8_t*)&gCamCapability[cameraId]->color_arrangement, 1);
1714
1715    int32_t pixel_array_size[] = {gCamCapability[cameraId]->pixel_array_size.width,
1716                                               gCamCapability[cameraId]->pixel_array_size.height};
1717    staticInfo.update(ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE,
1718                      pixel_array_size, 2);
1719
1720    int32_t active_array_size[] = {0, 0,
1721                                                gCamCapability[cameraId]->active_array_size.width,
1722                                                gCamCapability[cameraId]->active_array_size.height};
1723
1724    staticInfo.update(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE,
1725                      active_array_size, 4);
1726
1727    staticInfo.update(ANDROID_SENSOR_INFO_WHITE_LEVEL,
1728            &gCamCapability[cameraId]->white_level, 1);
1729
1730    staticInfo.update(ANDROID_SENSOR_BLACK_LEVEL_PATTERN,
1731            gCamCapability[cameraId]->black_level_pattern, 4);
1732
1733    staticInfo.update(ANDROID_FLASH_INFO_CHARGE_DURATION,
1734                      &gCamCapability[cameraId]->flash_charge_duration, 1);
1735
1736    staticInfo.update(ANDROID_TONEMAP_MAX_CURVE_POINTS,
1737                      &gCamCapability[cameraId]->max_tone_map_curve_points, 1);
1738
1739    /*staticInfo.update(ANDROID_STATISTICS_INFO_MAX_FACE_COUNT,
1740                      (int*)&gCamCapability[cameraId]->max_face_detection_count, 1);*/
1741    /*hardcode 0 for now*/
1742    int32_t max_face_count = 0;
1743    staticInfo.update(ANDROID_STATISTICS_INFO_MAX_FACE_COUNT,
1744                      &max_face_count, 1);
1745
1746    staticInfo.update(ANDROID_STATISTICS_INFO_HISTOGRAM_BUCKET_COUNT,
1747                      &gCamCapability[cameraId]->histogram_size, 1);
1748
1749    staticInfo.update(ANDROID_STATISTICS_INFO_MAX_HISTOGRAM_COUNT,
1750            &gCamCapability[cameraId]->max_histogram_count, 1);
1751
1752    int32_t sharpness_map_size[] = {gCamCapability[cameraId]->sharpness_map_size.width,
1753                                                gCamCapability[cameraId]->sharpness_map_size.height};
1754
1755    staticInfo.update(ANDROID_STATISTICS_INFO_SHARPNESS_MAP_SIZE,
1756            sharpness_map_size, sizeof(sharpness_map_size)/sizeof(int32_t));
1757
1758    staticInfo.update(ANDROID_STATISTICS_INFO_MAX_SHARPNESS_MAP_VALUE,
1759            &gCamCapability[cameraId]->max_sharpness_map_value, 1);
1760
1761
1762    staticInfo.update(ANDROID_SCALER_AVAILABLE_RAW_MIN_DURATIONS,
1763                      &gCamCapability[cameraId]->raw_min_duration,
1764                       1);
1765
1766    int32_t scalar_formats[] = {HAL_PIXEL_FORMAT_YCbCr_420_888,
1767                                                HAL_PIXEL_FORMAT_BLOB};
1768    int scalar_formats_count = sizeof(scalar_formats)/sizeof(int32_t);
1769    staticInfo.update(ANDROID_SCALER_AVAILABLE_FORMATS,
1770                      scalar_formats,
1771                      scalar_formats_count);
1772
1773    int32_t available_processed_sizes[CAM_FORMAT_MAX * 2];
1774    makeTable(gCamCapability[cameraId]->supported_sizes_tbl,
1775              gCamCapability[cameraId]->supported_sizes_tbl_cnt,
1776              available_processed_sizes);
1777    staticInfo.update(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES,
1778                available_processed_sizes,
1779                (gCamCapability[cameraId]->supported_sizes_tbl_cnt) * 2);
1780
1781    int32_t available_fps_ranges[MAX_SIZES_CNT * 2];
1782    makeFPSTable(gCamCapability[cameraId]->fps_ranges_tbl,
1783                 gCamCapability[cameraId]->fps_ranges_tbl_cnt,
1784                 available_fps_ranges);
1785    staticInfo.update(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
1786            available_fps_ranges, (gCamCapability[cameraId]->fps_ranges_tbl_cnt*2) );
1787
1788    camera_metadata_rational exposureCompensationStep = {
1789            gCamCapability[cameraId]->exp_compensation_step.numerator,
1790            gCamCapability[cameraId]->exp_compensation_step.denominator};
1791    staticInfo.update(ANDROID_CONTROL_AE_COMPENSATION_STEP,
1792                      &exposureCompensationStep, 1);
1793
1794    /*TO DO*/
1795    uint8_t availableVstabModes[] = {ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF};
1796    staticInfo.update(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES,
1797                      availableVstabModes, sizeof(availableVstabModes));
1798
1799    /*HAL 1 and HAL 3 common*/
1800    float maxZoom = 4;
1801    staticInfo.update(ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM,
1802            &maxZoom, 1);
1803
1804    int32_t max3aRegions = 1;
1805    staticInfo.update(ANDROID_CONTROL_MAX_REGIONS,
1806            &max3aRegions, 1);
1807
1808    uint8_t availableFaceDetectModes[] = {
1809            ANDROID_STATISTICS_FACE_DETECT_MODE_OFF };
1810    staticInfo.update(ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES,
1811                      availableFaceDetectModes,
1812                      sizeof(availableFaceDetectModes));
1813
1814    int32_t raw_size[] = {gCamCapability[cameraId]->raw_dim.width,
1815                                       gCamCapability[cameraId]->raw_dim.height};
1816    staticInfo.update(ANDROID_SCALER_AVAILABLE_RAW_SIZES,
1817                      raw_size,
1818                      sizeof(raw_size)/sizeof(uint32_t));
1819
1820    int32_t exposureCompensationRange[] = {gCamCapability[cameraId]->exposure_compensation_min,
1821                                                        gCamCapability[cameraId]->exposure_compensation_max};
1822    staticInfo.update(ANDROID_CONTROL_AE_COMPENSATION_RANGE,
1823            exposureCompensationRange,
1824            sizeof(exposureCompensationRange)/sizeof(int32_t));
1825
1826    uint8_t lensFacing = (facingBack) ?
1827            ANDROID_LENS_FACING_BACK : ANDROID_LENS_FACING_FRONT;
1828    staticInfo.update(ANDROID_LENS_FACING, &lensFacing, 1);
1829
1830    int32_t available_jpeg_sizes[MAX_SIZES_CNT * 2];
1831    makeTable(gCamCapability[cameraId]->picture_sizes_tbl,
1832              gCamCapability[cameraId]->picture_sizes_tbl_cnt,
1833              available_jpeg_sizes);
1834    staticInfo.update(ANDROID_SCALER_AVAILABLE_JPEG_SIZES,
1835                available_jpeg_sizes,
1836                (gCamCapability[cameraId]->picture_sizes_tbl_cnt * 2));
1837
1838    staticInfo.update(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES,
1839                      available_thumbnail_sizes,
1840                      sizeof(available_thumbnail_sizes)/sizeof(int32_t));
1841
1842    int32_t max_jpeg_size = 0;
1843    int temp_width, temp_height;
1844    for (int i = 0; i < gCamCapability[cameraId]->picture_sizes_tbl_cnt; i++) {
1845        temp_width = gCamCapability[cameraId]->picture_sizes_tbl[i].width;
1846        temp_height = gCamCapability[cameraId]->picture_sizes_tbl[i].height;
1847        if (temp_width * temp_height > max_jpeg_size ) {
1848            max_jpeg_size = temp_width * temp_height;
1849        }
1850    }
1851    max_jpeg_size = max_jpeg_size * 3/2 + sizeof(camera3_jpeg_blob_t);
1852    staticInfo.update(ANDROID_JPEG_MAX_SIZE,
1853                      &max_jpeg_size, 1);
1854
1855    uint8_t avail_effects[CAM_EFFECT_MODE_MAX];
1856    int32_t size = 0;
1857    for (int i = 0; i < gCamCapability[cameraId]->supported_effects_cnt; i++) {
1858        int val = lookupFwkName(EFFECT_MODES_MAP,
1859                                   sizeof(EFFECT_MODES_MAP)/sizeof(EFFECT_MODES_MAP[0]),
1860                                   gCamCapability[cameraId]->supported_effects[i]);
1861        if (val != NAME_NOT_FOUND) {
1862            avail_effects[size] = (uint8_t)val;
1863            size++;
1864        }
1865    }
1866    staticInfo.update(ANDROID_CONTROL_AVAILABLE_EFFECTS,
1867                      avail_effects,
1868                      size);
1869
1870    uint8_t avail_scene_modes[CAM_SCENE_MODE_MAX];
1871    uint8_t supported_indexes[CAM_SCENE_MODE_MAX];
1872    int32_t supported_scene_modes_cnt = 0;
1873    for (int i = 0; i < gCamCapability[cameraId]->supported_scene_modes_cnt; i++) {
1874        int val = lookupFwkName(SCENE_MODES_MAP,
1875                                sizeof(SCENE_MODES_MAP)/sizeof(SCENE_MODES_MAP[0]),
1876                                gCamCapability[cameraId]->supported_scene_modes[i]);
1877        if (val != NAME_NOT_FOUND) {
1878            avail_scene_modes[supported_scene_modes_cnt] = (uint8_t)val;
1879            supported_indexes[supported_scene_modes_cnt] = i;
1880            supported_scene_modes_cnt++;
1881        }
1882    }
1883
1884    staticInfo.update(ANDROID_CONTROL_AVAILABLE_SCENE_MODES,
1885                      avail_scene_modes,
1886                      supported_scene_modes_cnt);
1887
1888    uint8_t scene_mode_overrides[CAM_SCENE_MODE_MAX * 3];
1889    makeOverridesList(gCamCapability[cameraId]->scene_mode_overrides,
1890                      supported_scene_modes_cnt,
1891                      scene_mode_overrides,
1892                      supported_indexes,
1893                      cameraId);
1894    staticInfo.update(ANDROID_CONTROL_SCENE_MODE_OVERRIDES,
1895                      scene_mode_overrides,
1896                      supported_scene_modes_cnt*3);
1897
1898    uint8_t avail_antibanding_modes[CAM_ANTIBANDING_MODE_MAX];
1899    size = 0;
1900    for (int i = 0; i < gCamCapability[cameraId]->supported_antibandings_cnt; i++) {
1901        int val = lookupFwkName(ANTIBANDING_MODES_MAP,
1902                                 sizeof(ANTIBANDING_MODES_MAP)/sizeof(ANTIBANDING_MODES_MAP[0]),
1903                                 gCamCapability[cameraId]->supported_antibandings[i]);
1904        if (val != NAME_NOT_FOUND) {
1905            avail_antibanding_modes[size] = (uint8_t)val;
1906            size++;
1907        }
1908
1909    }
1910    staticInfo.update(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES,
1911                      avail_antibanding_modes,
1912                      size);
1913
1914    uint8_t avail_af_modes[CAM_FOCUS_MODE_MAX];
1915    size = 0;
1916    for (int i = 0; i < gCamCapability[cameraId]->supported_focus_modes_cnt; i++) {
1917        int val = lookupFwkName(FOCUS_MODES_MAP,
1918                                sizeof(FOCUS_MODES_MAP)/sizeof(FOCUS_MODES_MAP[0]),
1919                                gCamCapability[cameraId]->supported_focus_modes[i]);
1920        if (val != NAME_NOT_FOUND) {
1921            avail_af_modes[size] = (uint8_t)val;
1922            size++;
1923        }
1924    }
1925    staticInfo.update(ANDROID_CONTROL_AF_AVAILABLE_MODES,
1926                      avail_af_modes,
1927                      size);
1928
1929    uint8_t avail_awb_modes[CAM_WB_MODE_MAX];
1930    size = 0;
1931    for (int i = 0; i < gCamCapability[cameraId]->supported_white_balances_cnt; i++) {
1932        int8_t val = lookupFwkName(WHITE_BALANCE_MODES_MAP,
1933                                    sizeof(WHITE_BALANCE_MODES_MAP)/sizeof(WHITE_BALANCE_MODES_MAP[0]),
1934                                    gCamCapability[cameraId]->supported_white_balances[i]);
1935        if (val != NAME_NOT_FOUND) {
1936            avail_awb_modes[size] = (uint8_t)val;
1937            size++;
1938        }
1939    }
1940    staticInfo.update(ANDROID_CONTROL_AWB_AVAILABLE_MODES,
1941                      avail_awb_modes,
1942                      size);
1943
1944    uint8_t avail_flash_modes[CAM_FLASH_MODE_MAX];
1945    size = 0;
1946    for (int i = 0; i < gCamCapability[cameraId]->supported_flash_modes_cnt; i++) {
1947        int val = lookupFwkName(FLASH_MODES_MAP,
1948                                sizeof(FLASH_MODES_MAP)/sizeof(FLASH_MODES_MAP[0]),
1949                                gCamCapability[cameraId]->supported_flash_modes[i]);
1950        if (val != NAME_NOT_FOUND) {
1951            avail_flash_modes[size] = (uint8_t)val;
1952            size++;
1953        }
1954    }
1955    static uint8_t flashAvailable = 0;
1956    if (size > 1) {
1957        //flash is supported
1958        flashAvailable = 1;
1959    }
1960    staticInfo.update(ANDROID_FLASH_MODE,
1961                      avail_flash_modes,
1962                      size);
1963
1964    staticInfo.update(ANDROID_FLASH_INFO_AVAILABLE,
1965            &flashAvailable, 1);
1966
1967    uint8_t avail_ae_modes[5];
1968    size = 0;
1969    for (int i = 0; i < gCamCapability[cameraId]->supported_ae_modes_cnt; i++) {
1970        avail_ae_modes[i] = gCamCapability[cameraId]->supported_ae_modes[i];
1971        size++;
1972    }
1973    if (flashAvailable) {
1974        avail_ae_modes[size++] = ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH;
1975        avail_ae_modes[size++] = ANDROID_CONTROL_AE_MODE_ON_ALWAYS_FLASH;
1976        avail_ae_modes[size++] = ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE;
1977    }
1978    staticInfo.update(ANDROID_CONTROL_AE_AVAILABLE_MODES,
1979                      avail_ae_modes,
1980                      size);
1981
1982    int32_t min = INT_MAX, max = INT_MIN;
1983    for (int i = 0; i < gCamCapability[cameraId]->supported_iso_modes_cnt; i++) {
1984        int32_t sensitivity = getSensorSensitivity(gCamCapability[cameraId]->supported_iso_modes[i]);
1985        if (sensitivity != -1) {
1986            min = (sensitivity >= min) ? min : sensitivity;
1987            max = (sensitivity <= max) ? max : sensitivity;
1988        }
1989    }
1990    int32_t sensitivity_range[] = {min, max};
1991    staticInfo.update(ANDROID_SENSOR_INFO_SENSITIVITY_RANGE,
1992                      sensitivity_range,
1993                      sizeof(sensitivity_range) / sizeof(int32_t));
1994
1995    staticInfo.update(ANDROID_SENSOR_MAX_ANALOG_SENSITIVITY,
1996                      &gCamCapability[cameraId]->max_analog_sensitivity,
1997                      sizeof(int32_t) );
1998    staticInfo.update(ANDROID_SCALER_AVAILABLE_PROCESSED_MIN_DURATIONS,
1999                      &gCamCapability[cameraId]->processed_min_duration,
2000                      sizeof(int32_t));
2001    staticInfo.update(ANDROID_SCALER_AVAILABLE_JPEG_MIN_DURATIONS,
2002                      &gCamCapability[cameraId]->jpeg_min_duration,
2003                      sizeof(int32_t));
2004
2005    gStaticMetadata[cameraId] = staticInfo.release();
2006    return rc;
2007}
2008
2009/*===========================================================================
2010 * FUNCTION   : makeTable
2011 *
2012 * DESCRIPTION: make a table of sizes
2013 *
2014 * PARAMETERS :
2015 *
2016 *
2017 *==========================================================================*/
2018void QCamera3HardwareInterface::makeTable(cam_dimension_t* dimTable, uint8_t size,
2019                                          int32_t* sizeTable)
2020{
2021    int j = 0;
2022    for (int i = 0; i < size; i++) {
2023        sizeTable[j] = dimTable[i].width;
2024        sizeTable[j+1] = dimTable[i].height;
2025        j+=2;
2026    }
2027}
2028
2029/*===========================================================================
2030 * FUNCTION   : makeFPSTable
2031 *
2032 * DESCRIPTION: make a table of fps ranges
2033 *
2034 * PARAMETERS :
2035 *
2036 *==========================================================================*/
2037void QCamera3HardwareInterface::makeFPSTable(cam_fps_range_t* fpsTable, uint8_t size,
2038                                          int32_t* fpsRangesTable)
2039{
2040    int j = 0;
2041    for (int i = 0; i < size; i++) {
2042        fpsRangesTable[j] = (int32_t)fpsTable[i].min_fps;
2043        fpsRangesTable[j+1] = (int32_t)fpsTable[i].max_fps;
2044        j+=2;
2045    }
2046}
2047
2048/*===========================================================================
2049 * FUNCTION   : makeOverridesList
2050 *
2051 * DESCRIPTION: make a list of scene mode overrides
2052 *
2053 * PARAMETERS :
2054 *
2055 *
2056 *==========================================================================*/
2057void QCamera3HardwareInterface::makeOverridesList(cam_scene_mode_overrides_t* overridesTable,
2058                                                  uint8_t size, uint8_t* overridesList,
2059                                                  uint8_t* supported_indexes,
2060                                                  int camera_id)
2061{
2062    /*daemon will give a list of overrides for all scene modes.
2063      However we should send the fwk only the overrides for the scene modes
2064      supported by the framework*/
2065    int j = 0, index = 0, supt = 0;
2066    uint8_t focus_override;
2067    for (int i = 0; i < size; i++) {
2068        supt = 0;
2069        index = supported_indexes[i];
2070        overridesList[j] = (uint8_t)overridesTable[index].ae_mode;
2071        overridesList[j+1] = (uint8_t)lookupFwkName(WHITE_BALANCE_MODES_MAP,
2072                                 sizeof(WHITE_BALANCE_MODES_MAP)/sizeof(WHITE_BALANCE_MODES_MAP[0]),
2073                                                    overridesTable[index].awb_mode);
2074        focus_override = (uint8_t)overridesTable[index].af_mode;
2075        for (int k = 0; k < gCamCapability[camera_id]->supported_focus_modes_cnt; k++) {
2076           if (gCamCapability[camera_id]->supported_focus_modes[k] == focus_override) {
2077              supt = 1;
2078              break;
2079           }
2080        }
2081        if (supt) {
2082           overridesList[j+2] = (uint8_t)lookupFwkName(FOCUS_MODES_MAP,
2083                                              sizeof(FOCUS_MODES_MAP)/sizeof(FOCUS_MODES_MAP[0]),
2084                                              focus_override);
2085        } else {
2086           overridesList[j+2] = ANDROID_CONTROL_AF_MODE_OFF;
2087        }
2088        j+=3;
2089    }
2090}
2091
2092/*===========================================================================
2093 * FUNCTION   : getPreviewHalPixelFormat
2094 *
2095 * DESCRIPTION: convert the format to type recognized by framework
2096 *
2097 * PARAMETERS : format : the format from backend
2098 *
2099 ** RETURN    : format recognized by framework
2100 *
2101 *==========================================================================*/
2102int32_t QCamera3HardwareInterface::getScalarFormat(int32_t format)
2103{
2104    int32_t halPixelFormat;
2105
2106    switch (format) {
2107    case CAM_FORMAT_YUV_420_NV12:
2108        halPixelFormat = HAL_PIXEL_FORMAT_YCbCr_420_SP;
2109        break;
2110    case CAM_FORMAT_YUV_420_NV21:
2111        halPixelFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP;
2112        break;
2113    case CAM_FORMAT_YUV_420_NV21_ADRENO:
2114        halPixelFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO;
2115        break;
2116    case CAM_FORMAT_YUV_420_YV12:
2117        halPixelFormat = HAL_PIXEL_FORMAT_YV12;
2118        break;
2119    case CAM_FORMAT_YUV_422_NV16:
2120    case CAM_FORMAT_YUV_422_NV61:
2121    default:
2122        halPixelFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP;
2123        break;
2124    }
2125    return halPixelFormat;
2126}
2127
2128/*===========================================================================
2129 * FUNCTION   : getSensorSensitivity
2130 *
2131 * DESCRIPTION: convert iso_mode to an integer value
2132 *
2133 * PARAMETERS : iso_mode : the iso_mode supported by sensor
2134 *
2135 ** RETURN    : sensitivity supported by sensor
2136 *
2137 *==========================================================================*/
2138int32_t QCamera3HardwareInterface::getSensorSensitivity(int32_t iso_mode)
2139{
2140    int32_t sensitivity;
2141
2142    switch (iso_mode) {
2143    case CAM_ISO_MODE_100:
2144        sensitivity = 100;
2145        break;
2146    case CAM_ISO_MODE_200:
2147        sensitivity = 200;
2148        break;
2149    case CAM_ISO_MODE_400:
2150        sensitivity = 400;
2151        break;
2152    case CAM_ISO_MODE_800:
2153        sensitivity = 800;
2154        break;
2155    case CAM_ISO_MODE_1600:
2156        sensitivity = 1600;
2157        break;
2158    default:
2159        sensitivity = -1;
2160        break;
2161    }
2162    return sensitivity;
2163}
2164
2165
2166/*===========================================================================
2167 * FUNCTION   : AddSetParmEntryToBatch
2168 *
2169 * DESCRIPTION: add set parameter entry into batch
2170 *
2171 * PARAMETERS :
2172 *   @p_table     : ptr to parameter buffer
2173 *   @paramType   : parameter type
2174 *   @paramLength : length of parameter value
2175 *   @paramValue  : ptr to parameter value
2176 *
2177 * RETURN     : int32_t type of status
2178 *              NO_ERROR  -- success
2179 *              none-zero failure code
2180 *==========================================================================*/
2181int32_t QCamera3HardwareInterface::AddSetParmEntryToBatch(parm_buffer_t *p_table,
2182                                                          cam_intf_parm_type_t paramType,
2183                                                          uint32_t paramLength,
2184                                                          void *paramValue)
2185{
2186    int position = paramType;
2187    int current, next;
2188
2189    /*************************************************************************
2190    *                 Code to take care of linking next flags                *
2191    *************************************************************************/
2192    current = GET_FIRST_PARAM_ID(p_table);
2193    if (position == current){
2194        //DO NOTHING
2195    } else if (position < current){
2196        SET_NEXT_PARAM_ID(position, p_table, current);
2197        SET_FIRST_PARAM_ID(p_table, position);
2198    } else {
2199        /* Search for the position in the linked list where we need to slot in*/
2200        while (position > GET_NEXT_PARAM_ID(current, p_table))
2201            current = GET_NEXT_PARAM_ID(current, p_table);
2202
2203        /*If node already exists no need to alter linking*/
2204        if (position != GET_NEXT_PARAM_ID(current, p_table)) {
2205            next = GET_NEXT_PARAM_ID(current, p_table);
2206            SET_NEXT_PARAM_ID(current, p_table, position);
2207            SET_NEXT_PARAM_ID(position, p_table, next);
2208        }
2209    }
2210
2211    /*************************************************************************
2212    *                   Copy contents into entry                             *
2213    *************************************************************************/
2214
2215    if (paramLength > sizeof(parm_type_t)) {
2216        ALOGE("%s:Size of input larger than max entry size",__func__);
2217        return BAD_VALUE;
2218    }
2219    memcpy(POINTER_OF(paramType,p_table), paramValue, paramLength);
2220    return NO_ERROR;
2221}
2222
2223/*===========================================================================
2224 * FUNCTION   : lookupFwkName
2225 *
2226 * DESCRIPTION: In case the enum is not same in fwk and backend
2227 *              make sure the parameter is correctly propogated
2228 *
2229 * PARAMETERS  :
2230 *   @arr      : map between the two enums
2231 *   @len      : len of the map
2232 *   @hal_name : name of the hal_parm to map
2233 *
2234 * RETURN     : int type of status
2235 *              fwk_name  -- success
2236 *              none-zero failure code
2237 *==========================================================================*/
2238int8_t QCamera3HardwareInterface::lookupFwkName(const QCameraMap arr[],
2239                                             int len, int hal_name)
2240{
2241
2242    for (int i = 0; i < len; i++) {
2243        if (arr[i].hal_name == hal_name)
2244            return arr[i].fwk_name;
2245    }
2246
2247    /* Not able to find matching framework type is not necessarily
2248     * an error case. This happens when mm-camera supports more attributes
2249     * than the frameworks do */
2250    ALOGD("%s: Cannot find matching framework type", __func__);
2251    return NAME_NOT_FOUND;
2252}
2253
2254/*===========================================================================
2255 * FUNCTION   : lookupHalName
2256 *
2257 * DESCRIPTION: In case the enum is not same in fwk and backend
2258 *              make sure the parameter is correctly propogated
2259 *
2260 * PARAMETERS  :
2261 *   @arr      : map between the two enums
2262 *   @len      : len of the map
2263 *   @fwk_name : name of the hal_parm to map
2264 *
2265 * RETURN     : int32_t type of status
2266 *              hal_name  -- success
2267 *              none-zero failure code
2268 *==========================================================================*/
2269int8_t QCamera3HardwareInterface::lookupHalName(const QCameraMap arr[],
2270                                             int len, int fwk_name)
2271{
2272    for (int i = 0; i < len; i++) {
2273       if (arr[i].fwk_name == fwk_name)
2274           return arr[i].hal_name;
2275    }
2276    ALOGE("%s: Cannot find matching hal type", __func__);
2277    return NAME_NOT_FOUND;
2278}
2279
2280/*===========================================================================
2281 * FUNCTION   : getCapabilities
2282 *
2283 * DESCRIPTION: query camera capabilities
2284 *
2285 * PARAMETERS :
2286 *   @cameraId  : camera Id
2287 *   @info      : camera info struct to be filled in with camera capabilities
2288 *
2289 * RETURN     : int32_t type of status
2290 *              NO_ERROR  -- success
2291 *              none-zero failure code
2292 *==========================================================================*/
2293int QCamera3HardwareInterface::getCamInfo(int cameraId,
2294                                    struct camera_info *info)
2295{
2296    int rc = 0;
2297
2298    if (NULL == gCamCapability[cameraId]) {
2299        rc = initCapabilities(cameraId);
2300        if (rc < 0) {
2301            //pthread_mutex_unlock(&g_camlock);
2302            return rc;
2303        }
2304    }
2305
2306    if (NULL == gStaticMetadata[cameraId]) {
2307        rc = initStaticMetadata(cameraId);
2308        if (rc < 0) {
2309            return rc;
2310        }
2311    }
2312
2313    switch(gCamCapability[cameraId]->position) {
2314    case CAM_POSITION_BACK:
2315        info->facing = CAMERA_FACING_BACK;
2316        break;
2317
2318    case CAM_POSITION_FRONT:
2319        info->facing = CAMERA_FACING_FRONT;
2320        break;
2321
2322    default:
2323        ALOGE("%s:Unknown position type for camera id:%d", __func__, cameraId);
2324        rc = -1;
2325        break;
2326    }
2327
2328
2329    info->orientation = gCamCapability[cameraId]->sensor_mount_angle;
2330    info->device_version = HARDWARE_DEVICE_API_VERSION(3, 0);
2331    info->static_camera_characteristics = gStaticMetadata[cameraId];
2332
2333    return rc;
2334}
2335
2336/*===========================================================================
2337 * FUNCTION   : translateMetadata
2338 *
2339 * DESCRIPTION: translate the metadata into camera_metadata_t
2340 *
2341 * PARAMETERS : type of the request
2342 *
2343 *
2344 * RETURN     : success: camera_metadata_t*
2345 *              failure: NULL
2346 *
2347 *==========================================================================*/
2348camera_metadata_t* QCamera3HardwareInterface::translateCapabilityToMetadata(int type)
2349{
2350    pthread_mutex_lock(&mMutex);
2351
2352    if (mDefaultMetadata[type] != NULL) {
2353        pthread_mutex_unlock(&mMutex);
2354        return mDefaultMetadata[type];
2355    }
2356    //first time we are handling this request
2357    //fill up the metadata structure using the wrapper class
2358    CameraMetadata settings;
2359    //translate from cam_capability_t to camera_metadata_tag_t
2360    static const uint8_t requestType = ANDROID_REQUEST_TYPE_CAPTURE;
2361    settings.update(ANDROID_REQUEST_TYPE, &requestType, 1);
2362
2363    /*control*/
2364
2365    uint8_t controlIntent = 0;
2366    switch (type) {
2367      case CAMERA3_TEMPLATE_PREVIEW:
2368        controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW;
2369        break;
2370      case CAMERA3_TEMPLATE_STILL_CAPTURE:
2371        controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE;
2372        break;
2373      case CAMERA3_TEMPLATE_VIDEO_RECORD:
2374        controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_RECORD;
2375        break;
2376      case CAMERA3_TEMPLATE_VIDEO_SNAPSHOT:
2377        controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT;
2378        break;
2379      case CAMERA3_TEMPLATE_ZERO_SHUTTER_LAG:
2380        controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_ZERO_SHUTTER_LAG;
2381        break;
2382      default:
2383        controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_CUSTOM;
2384        break;
2385    }
2386    settings.update(ANDROID_CONTROL_CAPTURE_INTENT, &controlIntent, 1);
2387
2388    settings.update(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION,
2389            &gCamCapability[mCameraId]->exposure_compensation_default, 1);
2390
2391    static const uint8_t aeLock = ANDROID_CONTROL_AE_LOCK_OFF;
2392    settings.update(ANDROID_CONTROL_AE_LOCK, &aeLock, 1);
2393
2394    static const uint8_t awbLock = ANDROID_CONTROL_AWB_LOCK_OFF;
2395    settings.update(ANDROID_CONTROL_AWB_LOCK, &awbLock, 1);
2396
2397    static const uint8_t awbMode = ANDROID_CONTROL_AWB_MODE_AUTO;
2398    settings.update(ANDROID_CONTROL_AWB_MODE, &awbMode, 1);
2399
2400    static const uint8_t controlMode = ANDROID_CONTROL_MODE_AUTO;
2401    settings.update(ANDROID_CONTROL_MODE, &controlMode, 1);
2402
2403    static const uint8_t effectMode = ANDROID_CONTROL_EFFECT_MODE_OFF;
2404    settings.update(ANDROID_CONTROL_EFFECT_MODE, &effectMode, 1);
2405
2406    static const uint8_t sceneMode = ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY; //similar to AUTO?
2407    settings.update(ANDROID_CONTROL_SCENE_MODE, &sceneMode, 1);
2408
2409    static uint8_t focusMode;
2410    if (gCamCapability[mCameraId]->supported_focus_modes_cnt > 1) {
2411        ALOGE("%s: Setting focus mode to auto", __func__);
2412        focusMode = ANDROID_CONTROL_AF_MODE_AUTO;
2413    } else {
2414        ALOGE("%s: Setting focus mode to off", __func__);
2415        focusMode = ANDROID_CONTROL_AF_MODE_OFF;
2416    }
2417    settings.update(ANDROID_CONTROL_AF_MODE, &focusMode, 1);
2418
2419    static const uint8_t aeMode = ANDROID_CONTROL_AE_MODE_ON;
2420    settings.update(ANDROID_CONTROL_AE_MODE, &aeMode, 1);
2421
2422    /*flash*/
2423    static const uint8_t flashMode = ANDROID_FLASH_MODE_OFF;
2424    settings.update(ANDROID_FLASH_MODE, &flashMode, 1);
2425
2426
2427    /* lens */
2428    float default_aperture = gCamCapability[mCameraId]->apertures[0];
2429    settings.update(ANDROID_LENS_APERTURE, &default_aperture, 1);
2430
2431    if (gCamCapability[mCameraId]->filter_densities_count) {
2432        float default_filter_density = gCamCapability[mCameraId]->filter_densities[0];
2433        settings.update(ANDROID_LENS_FILTER_DENSITY, &default_filter_density,
2434                        gCamCapability[mCameraId]->filter_densities_count);
2435    }
2436
2437    float default_focal_length = gCamCapability[mCameraId]->focal_length;
2438    settings.update(ANDROID_LENS_FOCAL_LENGTH, &default_focal_length, 1);
2439
2440    mDefaultMetadata[type] = settings.release();
2441
2442    pthread_mutex_unlock(&mMutex);
2443    return mDefaultMetadata[type];
2444}
2445
2446/*===========================================================================
2447 * FUNCTION   : setFrameParameters
2448 *
2449 * DESCRIPTION: set parameters per frame as requested in the metadata from
2450 *              framework
2451 *
2452 * PARAMETERS :
2453 *   @settings  : frame settings information from framework
2454 *
2455 *
2456 * RETURN     : success: NO_ERROR
2457 *              failure:
2458 *==========================================================================*/
2459int QCamera3HardwareInterface::setFrameParameters(int frame_id,
2460                                                  const camera_metadata_t *settings)
2461{
2462    /*translate from camera_metadata_t type to parm_type_t*/
2463    int rc = 0;
2464    if (settings == NULL && mFirstRequest) {
2465        /*settings cannot be null for the first request*/
2466        return BAD_VALUE;
2467    }
2468
2469    int32_t hal_version = CAM_HAL_V3;
2470
2471    memset(mParameters, 0, sizeof(parm_buffer_t));
2472    mParameters->first_flagged_entry = CAM_INTF_PARM_MAX;
2473    AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_HAL_VERSION,
2474                sizeof(hal_version), &hal_version);
2475
2476    /*we need to update the frame number in the parameters*/
2477    rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_FRAME_NUMBER,
2478                                sizeof(frame_id), &frame_id);
2479    if (rc < 0) {
2480        ALOGE("%s: Failed to set the frame number in the parameters", __func__);
2481        return BAD_VALUE;
2482    }
2483
2484    if(settings != NULL){
2485        rc = translateMetadataToParameters(settings);
2486    }
2487    /*set the parameters to backend*/
2488    mCameraHandle->ops->set_parms(mCameraHandle->camera_handle, mParameters);
2489    return rc;
2490}
2491
2492/*===========================================================================
2493 * FUNCTION   : translateMetadataToParameters
2494 *
2495 * DESCRIPTION: read from the camera_metadata_t and change to parm_type_t
2496 *
2497 *
2498 * PARAMETERS :
2499 *   @settings  : frame settings information from framework
2500 *
2501 *
2502 * RETURN     : success: NO_ERROR
2503 *              failure:
2504 *==========================================================================*/
2505int QCamera3HardwareInterface::translateMetadataToParameters
2506                                  (const camera_metadata_t *settings)
2507{
2508    int rc = 0;
2509    CameraMetadata frame_settings;
2510    frame_settings = settings;
2511
2512
2513    if (frame_settings.exists(ANDROID_CONTROL_AE_ANTIBANDING_MODE)) {
2514        int32_t antibandingMode =
2515            frame_settings.find(ANDROID_CONTROL_AE_ANTIBANDING_MODE).data.i32[0];
2516        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_ANTIBANDING,
2517                sizeof(antibandingMode), &antibandingMode);
2518    }
2519
2520    if (frame_settings.exists(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION)) {
2521        int32_t expCompensation = frame_settings.find(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION).data.i32[0];
2522        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_EXPOSURE_COMPENSATION,
2523          sizeof(expCompensation), &expCompensation);
2524    }
2525
2526    if (frame_settings.exists(ANDROID_CONTROL_AE_LOCK)) {
2527        uint8_t aeLock = frame_settings.find(ANDROID_CONTROL_AE_LOCK).data.u8[0];
2528        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_AEC_LOCK,
2529                sizeof(aeLock), &aeLock);
2530    }
2531
2532    if (frame_settings.exists(ANDROID_CONTROL_AE_TARGET_FPS_RANGE)) {
2533        cam_fps_range_t fps_range;
2534        fps_range.min_fps =
2535            frame_settings.find(ANDROID_CONTROL_AE_TARGET_FPS_RANGE).data.i32[0];
2536        fps_range.max_fps =
2537            frame_settings.find(ANDROID_CONTROL_AE_TARGET_FPS_RANGE).data.i32[1];
2538        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_FPS_RANGE,
2539                sizeof(fps_range), &fps_range);
2540    }
2541
2542    float focalDistance = -1.0;
2543    if (frame_settings.exists(ANDROID_LENS_FOCUS_DISTANCE)) {
2544        focalDistance = frame_settings.find(ANDROID_LENS_FOCUS_DISTANCE).data.f[0];
2545        rc = AddSetParmEntryToBatch(mParameters,
2546                CAM_INTF_META_LENS_FOCUS_DISTANCE,
2547                sizeof(focalDistance), &focalDistance);
2548    }
2549
2550    if (frame_settings.exists(ANDROID_CONTROL_AF_MODE)) {
2551        uint8_t fwk_focusMode =
2552            frame_settings.find(ANDROID_CONTROL_AF_MODE).data.u8[0];
2553        uint8_t focusMode;
2554        if (focalDistance == 0.0 && fwk_focusMode == ANDROID_CONTROL_AF_MODE_OFF) {
2555            focusMode = CAM_FOCUS_MODE_INFINITY;
2556        } else{
2557         focusMode = lookupHalName(FOCUS_MODES_MAP,
2558                                   sizeof(FOCUS_MODES_MAP),
2559                                   fwk_focusMode);
2560        }
2561        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_FOCUS_MODE,
2562                sizeof(focusMode), &focusMode);
2563    }
2564
2565    if (frame_settings.exists(ANDROID_CONTROL_AWB_LOCK)) {
2566        uint8_t awbLock =
2567            frame_settings.find(ANDROID_CONTROL_AWB_LOCK).data.u8[0];
2568        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_AWB_LOCK,
2569                sizeof(awbLock), &awbLock);
2570    }
2571
2572    if (frame_settings.exists(ANDROID_CONTROL_AWB_MODE)) {
2573        uint8_t fwk_whiteLevel =
2574            frame_settings.find(ANDROID_CONTROL_AWB_MODE).data.u8[0];
2575        uint8_t whiteLevel = lookupHalName(WHITE_BALANCE_MODES_MAP,
2576                sizeof(WHITE_BALANCE_MODES_MAP),
2577                fwk_whiteLevel);
2578        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_WHITE_BALANCE,
2579                sizeof(whiteLevel), &whiteLevel);
2580    }
2581
2582    if (frame_settings.exists(ANDROID_CONTROL_EFFECT_MODE)) {
2583        uint8_t fwk_effectMode =
2584            frame_settings.find(ANDROID_CONTROL_EFFECT_MODE).data.u8[0];
2585        uint8_t effectMode = lookupHalName(EFFECT_MODES_MAP,
2586                sizeof(EFFECT_MODES_MAP),
2587                fwk_effectMode);
2588        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_EFFECT,
2589                sizeof(effectMode), &effectMode);
2590    }
2591
2592    if (frame_settings.exists(ANDROID_CONTROL_AE_MODE)) {
2593        uint8_t fwk_aeMode =
2594            frame_settings.find(ANDROID_CONTROL_AE_MODE).data.u8[0];
2595        uint8_t aeMode;
2596        int32_t redeye;
2597        if (fwk_aeMode == ANDROID_CONTROL_AE_MODE_OFF ) {
2598            aeMode = CAM_AE_MODE_OFF;
2599        } else {
2600            aeMode = CAM_AE_MODE_ON;
2601        }
2602        if (fwk_aeMode == ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE) {
2603            redeye = 1;
2604        } else {
2605            redeye = 0;
2606        }
2607        int32_t flashMode = (int32_t)lookupHalName(AE_FLASH_MODE_MAP,
2608                                          sizeof(AE_FLASH_MODE_MAP),
2609                                          fwk_aeMode);
2610        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_AEC_MODE,
2611                sizeof(aeMode), &aeMode);
2612        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_LED_MODE,
2613                sizeof(flashMode), &flashMode);
2614        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_REDEYE_REDUCTION,
2615                sizeof(redeye), &redeye);
2616    }
2617
2618    if (frame_settings.exists(ANDROID_REQUEST_FRAME_COUNT)) {
2619        int32_t metaFrameNumber =
2620            frame_settings.find(ANDROID_REQUEST_FRAME_COUNT).data.i32[0];
2621        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_FRAME_NUMBER,
2622                sizeof(metaFrameNumber), &metaFrameNumber);
2623    }
2624
2625    if (frame_settings.exists(ANDROID_COLOR_CORRECTION_MODE)) {
2626        uint8_t colorCorrectMode =
2627            frame_settings.find(ANDROID_COLOR_CORRECTION_MODE).data.u8[0];
2628        rc =
2629            AddSetParmEntryToBatch(mParameters, CAM_INTF_META_COLOR_CORRECT_MODE,
2630                    sizeof(colorCorrectMode), &colorCorrectMode);
2631    }
2632    cam_trigger_t aecTrigger;
2633    aecTrigger.trigger = CAM_AEC_TRIGGER_IDLE;
2634    aecTrigger.trigger_id = -1;
2635    if (frame_settings.exists(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER)&&
2636        frame_settings.exists(ANDROID_CONTROL_AE_PRECAPTURE_ID)) {
2637        aecTrigger.trigger =
2638            frame_settings.find(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER).data.u8[0];
2639        aecTrigger.trigger_id =
2640            frame_settings.find(ANDROID_CONTROL_AE_PRECAPTURE_ID).data.i32[0];
2641    }
2642    rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_AEC_PRECAPTURE_TRIGGER,
2643                                sizeof(aecTrigger), &aecTrigger);
2644
2645    /*af_trigger must come with a trigger id*/
2646    if (frame_settings.exists(ANDROID_CONTROL_AF_TRIGGER) &&
2647        frame_settings.exists(ANDROID_CONTROL_AF_TRIGGER_ID)) {
2648        cam_trigger_t af_trigger;
2649        af_trigger.trigger =
2650            frame_settings.find(ANDROID_CONTROL_AF_TRIGGER).data.u8[0];
2651        af_trigger.trigger_id =
2652            frame_settings.find(ANDROID_CONTROL_AF_TRIGGER_ID).data.i32[0];
2653        rc = AddSetParmEntryToBatch(mParameters,
2654                CAM_INTF_META_AF_TRIGGER, sizeof(af_trigger), &af_trigger);
2655    }
2656
2657    if (frame_settings.exists(ANDROID_CONTROL_MODE)) {
2658        uint8_t metaMode = frame_settings.find(ANDROID_CONTROL_MODE).data.u8[0];
2659        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_MODE,
2660                sizeof(metaMode), &metaMode);
2661        if (metaMode == ANDROID_CONTROL_MODE_USE_SCENE_MODE) {
2662           uint8_t fwk_sceneMode = frame_settings.find(ANDROID_CONTROL_SCENE_MODE).data.u8[0];
2663           uint8_t sceneMode = lookupHalName(SCENE_MODES_MAP,
2664                                             sizeof(SCENE_MODES_MAP)/sizeof(SCENE_MODES_MAP[0]),
2665                                             fwk_sceneMode);
2666           rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_BESTSHOT_MODE,
2667                sizeof(sceneMode), &sceneMode);
2668        } else if (metaMode == ANDROID_CONTROL_MODE_OFF) {
2669           uint8_t sceneMode = 0;//CAMERA_BESTSHOT_OFF;
2670           rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_BESTSHOT_MODE,
2671                sizeof(sceneMode), &sceneMode);
2672        } else if (metaMode == ANDROID_CONTROL_MODE_AUTO) {
2673           uint8_t sceneMode = 0;//CAMERA_BESTSHOT_OFF;
2674           rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_BESTSHOT_MODE,
2675                sizeof(sceneMode), &sceneMode);
2676        }
2677    }
2678
2679    if (frame_settings.exists(ANDROID_DEMOSAIC_MODE)) {
2680        int32_t demosaic =
2681            frame_settings.find(ANDROID_DEMOSAIC_MODE).data.u8[0];
2682        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_DEMOSAIC,
2683                sizeof(demosaic), &demosaic);
2684    }
2685
2686    if (frame_settings.exists(ANDROID_EDGE_MODE)) {
2687        uint8_t edgeMode = frame_settings.find(ANDROID_EDGE_MODE).data.u8[0];
2688        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_EDGE,
2689                sizeof(edgeMode), &edgeMode);
2690    }
2691
2692    if (frame_settings.exists(ANDROID_EDGE_STRENGTH)) {
2693        int32_t edgeStrength =
2694            frame_settings.find(ANDROID_EDGE_STRENGTH).data.i32[0];
2695        rc = AddSetParmEntryToBatch(mParameters,
2696                CAM_INTF_META_SHARPNESS_STRENGTH, sizeof(edgeStrength), &edgeStrength);
2697    }
2698
2699    if (frame_settings.exists(ANDROID_FLASH_MODE)) {
2700        uint8_t flashMode =
2701            frame_settings.find(ANDROID_FLASH_MODE).data.u8[0];
2702        rc = AddSetParmEntryToBatch(mParameters,
2703                CAM_INTF_META_FLASH_MODE, sizeof(flashMode), &flashMode);
2704    }
2705
2706    if (frame_settings.exists(ANDROID_FLASH_FIRING_POWER)) {
2707        uint8_t flashPower =
2708            frame_settings.find(ANDROID_FLASH_FIRING_POWER).data.u8[0];
2709        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_FLASH_POWER,
2710                sizeof(flashPower), &flashPower);
2711    }
2712
2713    if (frame_settings.exists(ANDROID_FLASH_FIRING_TIME)) {
2714        int64_t flashFiringTime =
2715            frame_settings.find(ANDROID_FLASH_FIRING_TIME).data.i64[0];
2716        rc = AddSetParmEntryToBatch(mParameters,
2717                CAM_INTF_META_FLASH_FIRING_TIME, sizeof(flashFiringTime), &flashFiringTime);
2718    }
2719
2720    if (frame_settings.exists(ANDROID_GEOMETRIC_MODE)) {
2721        uint8_t geometricMode =
2722            frame_settings.find(ANDROID_GEOMETRIC_MODE).data.u8[0];
2723        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_GEOMETRIC_MODE,
2724                sizeof(geometricMode), &geometricMode);
2725    }
2726
2727    if (frame_settings.exists(ANDROID_GEOMETRIC_STRENGTH)) {
2728        uint8_t geometricStrength =
2729            frame_settings.find(ANDROID_GEOMETRIC_STRENGTH).data.u8[0];
2730        rc = AddSetParmEntryToBatch(mParameters,
2731                CAM_INTF_META_GEOMETRIC_STRENGTH,
2732                sizeof(geometricStrength), &geometricStrength);
2733    }
2734
2735    if (frame_settings.exists(ANDROID_HOT_PIXEL_MODE)) {
2736        uint8_t hotPixelMode =
2737            frame_settings.find(ANDROID_HOT_PIXEL_MODE).data.u8[0];
2738        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_HOTPIXEL_MODE,
2739                sizeof(hotPixelMode), &hotPixelMode);
2740    }
2741
2742    if (frame_settings.exists(ANDROID_LENS_APERTURE)) {
2743        float lensAperture =
2744            frame_settings.find( ANDROID_LENS_APERTURE).data.f[0];
2745        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_LENS_APERTURE,
2746                sizeof(lensAperture), &lensAperture);
2747    }
2748
2749    if (frame_settings.exists(ANDROID_LENS_FILTER_DENSITY)) {
2750        float filterDensity =
2751            frame_settings.find(ANDROID_LENS_FILTER_DENSITY).data.f[0];
2752        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_LENS_FILTERDENSITY,
2753                sizeof(filterDensity), &filterDensity);
2754    }
2755
2756    if (frame_settings.exists(ANDROID_LENS_FOCAL_LENGTH)) {
2757        float focalLength =
2758            frame_settings.find(ANDROID_LENS_FOCAL_LENGTH).data.f[0];
2759        rc = AddSetParmEntryToBatch(mParameters,
2760                CAM_INTF_META_LENS_FOCAL_LENGTH,
2761                sizeof(focalLength), &focalLength);
2762    }
2763
2764    if (frame_settings.exists(ANDROID_LENS_OPTICAL_STABILIZATION_MODE)) {
2765        uint8_t optStabMode =
2766            frame_settings.find(ANDROID_LENS_OPTICAL_STABILIZATION_MODE).data.u8[0];
2767        rc = AddSetParmEntryToBatch(mParameters,
2768                CAM_INTF_META_LENS_OPT_STAB_MODE,
2769                sizeof(optStabMode), &optStabMode);
2770    }
2771
2772    if (frame_settings.exists(ANDROID_NOISE_REDUCTION_MODE)) {
2773        uint8_t noiseRedMode =
2774            frame_settings.find(ANDROID_NOISE_REDUCTION_MODE).data.u8[0];
2775        rc = AddSetParmEntryToBatch(mParameters,
2776                CAM_INTF_META_NOISE_REDUCTION_MODE,
2777                sizeof(noiseRedMode), &noiseRedMode);
2778    }
2779
2780    if (frame_settings.exists(ANDROID_NOISE_REDUCTION_STRENGTH)) {
2781        uint8_t noiseRedStrength =
2782            frame_settings.find(ANDROID_NOISE_REDUCTION_STRENGTH).data.u8[0];
2783        rc = AddSetParmEntryToBatch(mParameters,
2784                CAM_INTF_META_NOISE_REDUCTION_STRENGTH,
2785                sizeof(noiseRedStrength), &noiseRedStrength);
2786    }
2787
2788    cam_crop_region_t scalerCropRegion;
2789    bool scalerCropSet = false;
2790    if (frame_settings.exists(ANDROID_SCALER_CROP_REGION)) {
2791        scalerCropRegion.left =
2792            frame_settings.find(ANDROID_SCALER_CROP_REGION).data.i32[0];
2793        scalerCropRegion.top =
2794            frame_settings.find(ANDROID_SCALER_CROP_REGION).data.i32[1];
2795        scalerCropRegion.width =
2796            frame_settings.find(ANDROID_SCALER_CROP_REGION).data.i32[2];
2797        scalerCropRegion.height =
2798            frame_settings.find(ANDROID_SCALER_CROP_REGION).data.i32[3];
2799        rc = AddSetParmEntryToBatch(mParameters,
2800                CAM_INTF_META_SCALER_CROP_REGION,
2801                sizeof(scalerCropRegion), &scalerCropRegion);
2802        scalerCropSet = true;
2803    }
2804
2805    if (frame_settings.exists(ANDROID_SENSOR_EXPOSURE_TIME)) {
2806        int64_t sensorExpTime =
2807            frame_settings.find(ANDROID_SENSOR_EXPOSURE_TIME).data.i64[0];
2808        rc = AddSetParmEntryToBatch(mParameters,
2809                CAM_INTF_META_SENSOR_EXPOSURE_TIME,
2810                sizeof(sensorExpTime), &sensorExpTime);
2811    }
2812
2813    if (frame_settings.exists(ANDROID_SENSOR_FRAME_DURATION)) {
2814        int64_t sensorFrameDuration =
2815            frame_settings.find(ANDROID_SENSOR_FRAME_DURATION).data.i64[0];
2816        rc = AddSetParmEntryToBatch(mParameters,
2817                CAM_INTF_META_SENSOR_FRAME_DURATION,
2818                sizeof(sensorFrameDuration), &sensorFrameDuration);
2819    }
2820
2821    if (frame_settings.exists(ANDROID_SENSOR_SENSITIVITY)) {
2822        int32_t sensorSensitivity =
2823            frame_settings.find(ANDROID_SENSOR_SENSITIVITY).data.i32[0];
2824        rc = AddSetParmEntryToBatch(mParameters,
2825                CAM_INTF_META_SENSOR_SENSITIVITY,
2826                sizeof(sensorSensitivity), &sensorSensitivity);
2827    }
2828
2829    if (frame_settings.exists(ANDROID_SHADING_MODE)) {
2830        int32_t shadingMode =
2831            frame_settings.find(ANDROID_SHADING_MODE).data.u8[0];
2832        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_SHADING_MODE,
2833                sizeof(shadingMode), &shadingMode);
2834    }
2835
2836    if (frame_settings.exists(ANDROID_SHADING_STRENGTH)) {
2837        uint8_t shadingStrength =
2838            frame_settings.find(ANDROID_SHADING_STRENGTH).data.u8[0];
2839        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_SHADING_STRENGTH,
2840                sizeof(shadingStrength), &shadingStrength);
2841    }
2842
2843    if (frame_settings.exists(ANDROID_STATISTICS_FACE_DETECT_MODE)) {
2844        uint8_t facedetectMode =
2845            frame_settings.find(ANDROID_STATISTICS_FACE_DETECT_MODE).data.u8[0];
2846        rc = AddSetParmEntryToBatch(mParameters,
2847                CAM_INTF_META_STATS_FACEDETECT_MODE,
2848                sizeof(facedetectMode), &facedetectMode);
2849    }
2850
2851    if (frame_settings.exists(ANDROID_STATISTICS_HISTOGRAM_MODE)) {
2852        uint8_t histogramMode =
2853            frame_settings.find(ANDROID_STATISTICS_HISTOGRAM_MODE).data.u8[0];
2854        rc = AddSetParmEntryToBatch(mParameters,
2855                CAM_INTF_META_STATS_HISTOGRAM_MODE,
2856                sizeof(histogramMode), &histogramMode);
2857    }
2858
2859    if (frame_settings.exists(ANDROID_STATISTICS_SHARPNESS_MAP_MODE)) {
2860        uint8_t sharpnessMapMode =
2861            frame_settings.find(ANDROID_STATISTICS_SHARPNESS_MAP_MODE).data.u8[0];
2862        rc = AddSetParmEntryToBatch(mParameters,
2863                CAM_INTF_META_STATS_SHARPNESS_MAP_MODE,
2864                sizeof(sharpnessMapMode), &sharpnessMapMode);
2865    }
2866
2867    if (frame_settings.exists(ANDROID_TONEMAP_MODE)) {
2868        uint8_t tonemapMode =
2869            frame_settings.find(ANDROID_TONEMAP_MODE).data.u8[0];
2870        rc = AddSetParmEntryToBatch(mParameters,
2871                CAM_INTF_META_TONEMAP_MODE,
2872                sizeof(tonemapMode), &tonemapMode);
2873    }
2874
2875    if (frame_settings.exists(ANDROID_CONTROL_CAPTURE_INTENT)) {
2876        uint8_t captureIntent =
2877            frame_settings.find(ANDROID_CONTROL_CAPTURE_INTENT).data.u8[0];
2878        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_CAPTURE_INTENT,
2879                sizeof(captureIntent), &captureIntent);
2880    }
2881
2882    if (frame_settings.exists(ANDROID_CONTROL_AE_REGIONS)) {
2883        cam_area_t roi;
2884        bool reset = true;
2885        convertFromRegions(&roi, settings, ANDROID_CONTROL_AE_REGIONS);
2886        if (scalerCropSet) {
2887            reset = resetIfNeededROI(&roi, &scalerCropRegion);
2888        }
2889        if (reset) {
2890            rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_AEC_ROI,
2891                    sizeof(roi), &roi);
2892        }
2893    }
2894
2895    if (frame_settings.exists(ANDROID_CONTROL_AF_REGIONS)) {
2896        cam_area_t roi;
2897        bool reset = true;
2898        convertFromRegions(&roi, settings, ANDROID_CONTROL_AF_REGIONS);
2899        if (scalerCropSet) {
2900            reset = resetIfNeededROI(&roi, &scalerCropRegion);
2901        }
2902        if (reset) {
2903            rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_AF_ROI,
2904                    sizeof(roi), &roi);
2905        }
2906    }
2907
2908    if (frame_settings.exists(ANDROID_CONTROL_AWB_REGIONS)) {
2909        cam_area_t roi;
2910        bool reset = true;
2911        convertFromRegions(&roi, settings, ANDROID_CONTROL_AWB_REGIONS);
2912        if (scalerCropSet) {
2913            reset = resetIfNeededROI(&roi, &scalerCropRegion);
2914        }
2915        if (reset) {
2916            rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_AWB_REGIONS,
2917                    sizeof(roi), &roi);
2918        }
2919    }
2920    return rc;
2921}
2922
2923/*===========================================================================
2924 * FUNCTION   : getJpegSettings
2925 *
2926 * DESCRIPTION: save the jpeg settings in the HAL
2927 *
2928 *
2929 * PARAMETERS :
2930 *   @settings  : frame settings information from framework
2931 *
2932 *
2933 * RETURN     : success: NO_ERROR
2934 *              failure:
2935 *==========================================================================*/
2936int QCamera3HardwareInterface::getJpegSettings
2937                                  (const camera_metadata_t *settings)
2938{
2939    if (mJpegSettings) {
2940        if (mJpegSettings->gps_timestamp) {
2941            free(mJpegSettings->gps_timestamp);
2942            mJpegSettings->gps_timestamp = NULL;
2943        }
2944        if (mJpegSettings->gps_coordinates) {
2945            for (int i = 0; i < 3; i++) {
2946                free(mJpegSettings->gps_coordinates[i]);
2947                mJpegSettings->gps_coordinates[i] = NULL;
2948            }
2949        }
2950        free(mJpegSettings);
2951        mJpegSettings = NULL;
2952    }
2953    mJpegSettings = (jpeg_settings_t*) malloc(sizeof(jpeg_settings_t));
2954    CameraMetadata jpeg_settings;
2955    jpeg_settings = settings;
2956
2957    if (jpeg_settings.exists(ANDROID_JPEG_ORIENTATION)) {
2958        mJpegSettings->jpeg_orientation =
2959            jpeg_settings.find(ANDROID_JPEG_ORIENTATION).data.i32[0];
2960    } else {
2961        mJpegSettings->jpeg_orientation = 0;
2962    }
2963    if (jpeg_settings.exists(ANDROID_JPEG_QUALITY)) {
2964        mJpegSettings->jpeg_quality =
2965            jpeg_settings.find(ANDROID_JPEG_QUALITY).data.u8[0];
2966    } else {
2967        mJpegSettings->jpeg_quality = 85;
2968    }
2969    if (jpeg_settings.exists(ANDROID_JPEG_THUMBNAIL_SIZE)) {
2970        mJpegSettings->thumbnail_size.width =
2971            jpeg_settings.find(ANDROID_JPEG_THUMBNAIL_SIZE).data.i32[0];
2972        mJpegSettings->thumbnail_size.height =
2973            jpeg_settings.find(ANDROID_JPEG_THUMBNAIL_SIZE).data.i32[1];
2974    } else {
2975        mJpegSettings->thumbnail_size.width = 0;
2976        mJpegSettings->thumbnail_size.height = 0;
2977    }
2978    if (jpeg_settings.exists(ANDROID_JPEG_GPS_COORDINATES)) {
2979        for (int i = 0; i < 3; i++) {
2980            mJpegSettings->gps_coordinates[i] = (double*)malloc(sizeof(double*));
2981            *(mJpegSettings->gps_coordinates[i]) =
2982                jpeg_settings.find(ANDROID_JPEG_GPS_COORDINATES).data.d[i];
2983        }
2984    } else{
2985       for (int i = 0; i < 3; i++) {
2986            mJpegSettings->gps_coordinates[i] = NULL;
2987        }
2988    }
2989
2990    if (jpeg_settings.exists(ANDROID_JPEG_GPS_TIMESTAMP)) {
2991        mJpegSettings->gps_timestamp = (int64_t*)malloc(sizeof(int64_t*));
2992        *(mJpegSettings->gps_timestamp) =
2993            jpeg_settings.find(ANDROID_JPEG_GPS_TIMESTAMP).data.i64[0];
2994    } else {
2995        mJpegSettings->gps_timestamp = NULL;
2996    }
2997
2998    if (jpeg_settings.exists(ANDROID_JPEG_GPS_PROCESSING_METHOD)) {
2999        int len = jpeg_settings.find(ANDROID_JPEG_GPS_PROCESSING_METHOD).count;
3000        for (int i = 0; i < len; i++) {
3001            mJpegSettings->gps_processing_method[i] =
3002                jpeg_settings.find(ANDROID_JPEG_GPS_PROCESSING_METHOD).data.u8[i];
3003        }
3004        if (mJpegSettings->gps_processing_method[len-1] != '\0') {
3005            mJpegSettings->gps_processing_method[len] = '\0';
3006        }
3007    } else {
3008        mJpegSettings->gps_processing_method[0] = '\0';
3009    }
3010
3011    if (jpeg_settings.exists(ANDROID_SENSOR_SENSITIVITY)) {
3012        mJpegSettings->sensor_sensitivity =
3013            jpeg_settings.find(ANDROID_SENSOR_SENSITIVITY).data.i32[0];
3014    } else {
3015        mJpegSettings->sensor_sensitivity = mMetadataResponse.iso_speed;
3016    }
3017
3018    if (jpeg_settings.exists(ANDROID_LENS_FOCAL_LENGTH)) {
3019        mJpegSettings->lens_focal_length =
3020            jpeg_settings.find(ANDROID_LENS_FOCAL_LENGTH).data.f[0];
3021    }
3022    if (jpeg_settings.exists(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION)) {
3023        mJpegSettings->exposure_compensation =
3024            jpeg_settings.find(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION).data.i32[0];
3025    }
3026    mJpegSettings->exposure_comp_step = gCamCapability[mCameraId]->exp_compensation_step;
3027    mJpegSettings->max_jpeg_size = calcMaxJpegSize();
3028    return 0;
3029}
3030
3031/*===========================================================================
3032 * FUNCTION   : captureResultCb
3033 *
3034 * DESCRIPTION: Callback handler for all channels (streams, as well as metadata)
3035 *
3036 * PARAMETERS :
3037 *   @frame  : frame information from mm-camera-interface
3038 *   @buffer : actual gralloc buffer to be returned to frameworks. NULL if metadata.
3039 *   @userdata: userdata
3040 *
3041 * RETURN     : NONE
3042 *==========================================================================*/
3043void QCamera3HardwareInterface::captureResultCb(mm_camera_super_buf_t *metadata,
3044                camera3_stream_buffer_t *buffer,
3045                uint32_t frame_number, void *userdata)
3046{
3047    QCamera3HardwareInterface *hw = (QCamera3HardwareInterface *)userdata;
3048    if (hw == NULL) {
3049        ALOGE("%s: Invalid hw %p", __func__, hw);
3050        return;
3051    }
3052
3053    hw->captureResultCb(metadata, buffer, frame_number);
3054    return;
3055}
3056
3057/*===========================================================================
3058 * FUNCTION   : initialize
3059 *
3060 * DESCRIPTION: Pass framework callback pointers to HAL
3061 *
3062 * PARAMETERS :
3063 *
3064 *
3065 * RETURN     : Success : 0
3066 *              Failure: -ENODEV
3067 *==========================================================================*/
3068
3069int QCamera3HardwareInterface::initialize(const struct camera3_device *device,
3070                                  const camera3_callback_ops_t *callback_ops)
3071{
3072    ALOGV("%s: E", __func__);
3073    QCamera3HardwareInterface *hw =
3074        reinterpret_cast<QCamera3HardwareInterface *>(device->priv);
3075    if (!hw) {
3076        ALOGE("%s: NULL camera device", __func__);
3077        return -ENODEV;
3078    }
3079
3080    int rc = hw->initialize(callback_ops);
3081    ALOGV("%s: X", __func__);
3082    return rc;
3083}
3084
3085/*===========================================================================
3086 * FUNCTION   : configure_streams
3087 *
3088 * DESCRIPTION:
3089 *
3090 * PARAMETERS :
3091 *
3092 *
3093 * RETURN     : Success: 0
3094 *              Failure: -EINVAL (if stream configuration is invalid)
3095 *                       -ENODEV (fatal error)
3096 *==========================================================================*/
3097
3098int QCamera3HardwareInterface::configure_streams(
3099        const struct camera3_device *device,
3100        camera3_stream_configuration_t *stream_list)
3101{
3102    ALOGV("%s: E", __func__);
3103    QCamera3HardwareInterface *hw =
3104        reinterpret_cast<QCamera3HardwareInterface *>(device->priv);
3105    if (!hw) {
3106        ALOGE("%s: NULL camera device", __func__);
3107        return -ENODEV;
3108    }
3109    int rc = hw->configureStreams(stream_list);
3110    ALOGV("%s: X", __func__);
3111    return rc;
3112}
3113
3114/*===========================================================================
3115 * FUNCTION   : register_stream_buffers
3116 *
3117 * DESCRIPTION: Register stream buffers with the device
3118 *
3119 * PARAMETERS :
3120 *
3121 * RETURN     :
3122 *==========================================================================*/
3123int QCamera3HardwareInterface::register_stream_buffers(
3124        const struct camera3_device *device,
3125        const camera3_stream_buffer_set_t *buffer_set)
3126{
3127    ALOGV("%s: E", __func__);
3128    QCamera3HardwareInterface *hw =
3129        reinterpret_cast<QCamera3HardwareInterface *>(device->priv);
3130    if (!hw) {
3131        ALOGE("%s: NULL camera device", __func__);
3132        return -ENODEV;
3133    }
3134    int rc = hw->registerStreamBuffers(buffer_set);
3135    ALOGV("%s: X", __func__);
3136    return rc;
3137}
3138
3139/*===========================================================================
3140 * FUNCTION   : construct_default_request_settings
3141 *
3142 * DESCRIPTION: Configure a settings buffer to meet the required use case
3143 *
3144 * PARAMETERS :
3145 *
3146 *
3147 * RETURN     : Success: Return valid metadata
3148 *              Failure: Return NULL
3149 *==========================================================================*/
3150const camera_metadata_t* QCamera3HardwareInterface::
3151    construct_default_request_settings(const struct camera3_device *device,
3152                                        int type)
3153{
3154
3155    ALOGV("%s: E", __func__);
3156    camera_metadata_t* fwk_metadata = NULL;
3157    QCamera3HardwareInterface *hw =
3158        reinterpret_cast<QCamera3HardwareInterface *>(device->priv);
3159    if (!hw) {
3160        ALOGE("%s: NULL camera device", __func__);
3161        return NULL;
3162    }
3163
3164    fwk_metadata = hw->translateCapabilityToMetadata(type);
3165
3166    ALOGV("%s: X", __func__);
3167    return fwk_metadata;
3168}
3169
3170/*===========================================================================
3171 * FUNCTION   : process_capture_request
3172 *
3173 * DESCRIPTION:
3174 *
3175 * PARAMETERS :
3176 *
3177 *
3178 * RETURN     :
3179 *==========================================================================*/
3180int QCamera3HardwareInterface::process_capture_request(
3181                    const struct camera3_device *device,
3182                    camera3_capture_request_t *request)
3183{
3184    ALOGV("%s: E", __func__);
3185    QCamera3HardwareInterface *hw =
3186        reinterpret_cast<QCamera3HardwareInterface *>(device->priv);
3187    if (!hw) {
3188        ALOGE("%s: NULL camera device", __func__);
3189        return -EINVAL;
3190    }
3191
3192    int rc = hw->processCaptureRequest(request);
3193    ALOGV("%s: X", __func__);
3194    return rc;
3195}
3196
3197/*===========================================================================
3198 * FUNCTION   : get_metadata_vendor_tag_ops
3199 *
3200 * DESCRIPTION:
3201 *
3202 * PARAMETERS :
3203 *
3204 *
3205 * RETURN     :
3206 *==========================================================================*/
3207
3208void QCamera3HardwareInterface::get_metadata_vendor_tag_ops(
3209                const struct camera3_device *device,
3210                vendor_tag_query_ops_t* ops)
3211{
3212    ALOGV("%s: E", __func__);
3213    QCamera3HardwareInterface *hw =
3214        reinterpret_cast<QCamera3HardwareInterface *>(device->priv);
3215    if (!hw) {
3216        ALOGE("%s: NULL camera device", __func__);
3217        return;
3218    }
3219
3220    hw->getMetadataVendorTagOps(ops);
3221    ALOGV("%s: X", __func__);
3222    return;
3223}
3224
3225/*===========================================================================
3226 * FUNCTION   : dump
3227 *
3228 * DESCRIPTION:
3229 *
3230 * PARAMETERS :
3231 *
3232 *
3233 * RETURN     :
3234 *==========================================================================*/
3235
3236void QCamera3HardwareInterface::dump(
3237                const struct camera3_device *device, int fd)
3238{
3239    ALOGV("%s: E", __func__);
3240    QCamera3HardwareInterface *hw =
3241        reinterpret_cast<QCamera3HardwareInterface *>(device->priv);
3242    if (!hw) {
3243        ALOGE("%s: NULL camera device", __func__);
3244        return;
3245    }
3246
3247    hw->dump(fd);
3248    ALOGV("%s: X", __func__);
3249    return;
3250}
3251
3252/*===========================================================================
3253 * FUNCTION   : close_camera_device
3254 *
3255 * DESCRIPTION:
3256 *
3257 * PARAMETERS :
3258 *
3259 *
3260 * RETURN     :
3261 *==========================================================================*/
3262int QCamera3HardwareInterface::close_camera_device(struct hw_device_t* device)
3263{
3264    ALOGV("%s: E", __func__);
3265    int ret = NO_ERROR;
3266    QCamera3HardwareInterface *hw =
3267        reinterpret_cast<QCamera3HardwareInterface *>(
3268            reinterpret_cast<camera3_device_t *>(device)->priv);
3269    if (!hw) {
3270        ALOGE("NULL camera device");
3271        return BAD_VALUE;
3272    }
3273    delete hw;
3274
3275    pthread_mutex_lock(&mCameraSessionLock);
3276    mCameraSessionActive = 0;
3277    pthread_mutex_unlock(&mCameraSessionLock);
3278    ALOGV("%s: X", __func__);
3279    return ret;
3280}
3281
3282}; //end namespace qcamera
3283