QCamera3HWI.cpp revision afbf95f30505ef79c75a7255d3c82880eb2ae683 
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                        mPendingBuffersMap.editValueFor(j->stream)--;
1051                    }
1052                }
1053                result.output_buffers = result_buffers;
1054
1055                mCallbackOps->process_capture_result(mCallbackOps, &result);
1056                ALOGV("%s: meta frame_number = %d, capture_time = %lld",
1057                        __func__, result.frame_number, current_capture_time);
1058                free_camera_metadata((camera_metadata_t *)result.result);
1059                delete[] result_buffers;
1060            } else {
1061                mCallbackOps->process_capture_result(mCallbackOps, &result);
1062                ALOGV("%s: meta frame_number = %d, capture_time = %lld",
1063                        __func__, result.frame_number, current_capture_time);
1064                free_camera_metadata((camera_metadata_t *)result.result);
1065            }
1066            // erase the element from the list
1067            i = mPendingRequestsList.erase(i);
1068        }
1069
1070
1071done_metadata:
1072        bool max_buffers_dequeued = false;
1073        for (size_t i = 0; i < mPendingBuffersMap.size(); i++) {
1074            const camera3_stream_t *stream = mPendingBuffersMap.keyAt(i);
1075            uint32_t queued_buffers = mPendingBuffersMap.valueAt(i);
1076            if (queued_buffers == stream->max_buffers) {
1077                max_buffers_dequeued = true;
1078                break;
1079            }
1080        }
1081        if (!max_buffers_dequeued) {
1082            // Unblock process_capture_request
1083            mPendingRequest = 0;
1084            pthread_cond_signal(&mRequestCond);
1085        }
1086    } else {
1087        // If the frame number doesn't exist in the pending request list,
1088        // directly send the buffer to the frameworks, and update pending buffers map
1089        // Otherwise, book-keep the buffer.
1090        List<PendingRequestInfo>::iterator i = mPendingRequestsList.begin();
1091        while (i != mPendingRequestsList.end() && i->frame_number != frame_number)
1092            i++;
1093        if (i == mPendingRequestsList.end()) {
1094            // Verify all pending requests frame_numbers are greater
1095            for (List<PendingRequestInfo>::iterator j = mPendingRequestsList.begin();
1096                    j != mPendingRequestsList.end(); j++) {
1097                if (j->frame_number < frame_number) {
1098                    ALOGE("%s: Error: pending frame number %d is smaller than %d",
1099                            __func__, j->frame_number, frame_number);
1100                }
1101            }
1102            camera3_capture_result_t result;
1103            result.result = NULL;
1104            result.frame_number = frame_number;
1105            result.num_output_buffers = 1;
1106            result.output_buffers = buffer;
1107            ALOGV("%s: result frame_number = %d, buffer = %p",
1108                    __func__, frame_number, buffer);
1109            mPendingBuffersMap.editValueFor(buffer->stream)--;
1110            mCallbackOps->process_capture_result(mCallbackOps, &result);
1111        } else {
1112            for (List<RequestedBufferInfo>::iterator j = i->buffers.begin();
1113                    j != i->buffers.end(); j++) {
1114                if (j->stream == buffer->stream) {
1115                    if (j->buffer != NULL) {
1116                        ALOGE("%s: Error: buffer is already set", __func__);
1117                    } else {
1118                        j->buffer = (camera3_stream_buffer_t *)malloc(
1119                                sizeof(camera3_stream_buffer_t));
1120                        *(j->buffer) = *buffer;
1121                        ALOGV("%s: cache buffer %p at result frame_number %d",
1122                                __func__, buffer, frame_number);
1123                    }
1124                }
1125            }
1126        }
1127    }
1128
1129    pthread_mutex_unlock(&mRequestLock);
1130    return;
1131}
1132
1133/*===========================================================================
1134 * FUNCTION   : translateCbMetadataToResultMetadata
1135 *
1136 * DESCRIPTION:
1137 *
1138 * PARAMETERS :
1139 *   @metadata : metadata information from callback
1140 *
1141 * RETURN     : camera_metadata_t*
1142 *              metadata in a format specified by fwk
1143 *==========================================================================*/
1144camera_metadata_t*
1145QCamera3HardwareInterface::translateCbMetadataToResultMetadata
1146                                (metadata_buffer_t *metadata, nsecs_t timestamp,
1147                                 int32_t request_id)
1148{
1149    CameraMetadata camMetadata;
1150    camera_metadata_t* resultMetadata;
1151
1152    camMetadata.update(ANDROID_SENSOR_TIMESTAMP, &timestamp, 1);
1153    camMetadata.update(ANDROID_REQUEST_ID, &request_id, 1);
1154
1155    /*CAM_INTF_META_HISTOGRAM - TODO*/
1156    /*cam_hist_stats_t  *histogram =
1157      (cam_hist_stats_t *)POINTER_OF(CAM_INTF_META_HISTOGRAM,
1158      metadata);*/
1159
1160    /*face detection*/
1161    cam_face_detection_data_t *faceDetectionInfo =(cam_face_detection_data_t *)
1162        POINTER_OF(CAM_INTF_META_FACE_DETECTION, metadata);
1163    uint8_t numFaces = faceDetectionInfo->num_faces_detected;
1164    int32_t faceIds[numFaces];
1165    uint8_t faceScores[numFaces];
1166    int32_t faceRectangles[numFaces * 4];
1167    int32_t faceLandmarks[numFaces * 6];
1168    int j = 0, k = 0;
1169    for (int i = 0; i < numFaces; i++) {
1170        faceIds[i] = faceDetectionInfo->faces[i].face_id;
1171        faceScores[i] = faceDetectionInfo->faces[i].score;
1172        convertToRegions(faceDetectionInfo->faces[i].face_boundary,
1173                faceRectangles+j, -1);
1174        convertLandmarks(faceDetectionInfo->faces[i], faceLandmarks+k);
1175        j+= 4;
1176        k+= 6;
1177    }
1178    if (numFaces > 0) {
1179        camMetadata.update(ANDROID_STATISTICS_FACE_IDS, faceIds, numFaces);
1180        camMetadata.update(ANDROID_STATISTICS_FACE_SCORES, faceScores, numFaces);
1181        camMetadata.update(ANDROID_STATISTICS_FACE_RECTANGLES,
1182            faceRectangles, numFaces*4);
1183        camMetadata.update(ANDROID_STATISTICS_FACE_LANDMARKS,
1184            faceLandmarks, numFaces*6);
1185    }
1186
1187    uint8_t  *color_correct_mode =
1188        (uint8_t *)POINTER_OF(CAM_INTF_META_COLOR_CORRECT_MODE, metadata);
1189    camMetadata.update(ANDROID_COLOR_CORRECTION_MODE, color_correct_mode, 1);
1190
1191    int32_t  *ae_precapture_id =
1192        (int32_t *)POINTER_OF(CAM_INTF_META_AEC_PRECAPTURE_ID, metadata);
1193    camMetadata.update(ANDROID_CONTROL_AE_PRECAPTURE_ID, ae_precapture_id, 1);
1194
1195    /*aec regions*/
1196    cam_area_t  *hAeRegions =
1197        (cam_area_t *)POINTER_OF(CAM_INTF_META_AEC_ROI, metadata);
1198    int32_t aeRegions[5];
1199    convertToRegions(hAeRegions->rect, aeRegions, hAeRegions->weight);
1200    camMetadata.update(ANDROID_CONTROL_AE_REGIONS, aeRegions, 5);
1201
1202    uint8_t  *ae_state =
1203        (uint8_t *)POINTER_OF(CAM_INTF_META_AEC_STATE, metadata);
1204    camMetadata.update(ANDROID_CONTROL_AE_STATE, ae_state, 1);
1205
1206    uint8_t  *focusMode =
1207        (uint8_t *)POINTER_OF(CAM_INTF_PARM_FOCUS_MODE, metadata);
1208    camMetadata.update(ANDROID_CONTROL_AF_MODE, focusMode, 1);
1209
1210    /*af regions*/
1211    cam_area_t  *hAfRegions =
1212        (cam_area_t *)POINTER_OF(CAM_INTF_META_AF_ROI, metadata);
1213    int32_t afRegions[5];
1214    convertToRegions(hAfRegions->rect, afRegions, hAfRegions->weight);
1215    camMetadata.update(ANDROID_CONTROL_AF_REGIONS, afRegions, 5);
1216
1217    uint8_t  *afState = (uint8_t *)POINTER_OF(CAM_INTF_META_AF_STATE, metadata);
1218    camMetadata.update(ANDROID_CONTROL_AF_STATE, afState, 1);
1219
1220    int32_t  *afTriggerId =
1221        (int32_t *)POINTER_OF(CAM_INTF_META_AF_TRIGGER_ID, metadata);
1222    camMetadata.update(ANDROID_CONTROL_AF_TRIGGER_ID, afTriggerId, 1);
1223
1224    uint8_t  *whiteBalance =
1225        (uint8_t *)POINTER_OF(CAM_INTF_PARM_WHITE_BALANCE, metadata);
1226    camMetadata.update(ANDROID_CONTROL_AWB_MODE, whiteBalance, 1);
1227
1228    /*awb regions*/
1229    cam_area_t  *hAwbRegions =
1230        (cam_area_t *)POINTER_OF(CAM_INTF_META_AWB_REGIONS, metadata);
1231    int32_t awbRegions[5];
1232    convertToRegions(hAwbRegions->rect, awbRegions, hAwbRegions->weight);
1233    camMetadata.update(ANDROID_CONTROL_AWB_REGIONS, awbRegions, 5);
1234
1235    uint8_t  *whiteBalanceState =
1236        (uint8_t *)POINTER_OF(CAM_INTF_META_AWB_STATE, metadata);
1237    camMetadata.update(ANDROID_CONTROL_AWB_STATE, whiteBalanceState, 1);
1238
1239    uint8_t  *mode = (uint8_t *)POINTER_OF(CAM_INTF_META_MODE, metadata);
1240    camMetadata.update(ANDROID_CONTROL_MODE, mode, 1);
1241
1242    uint8_t  *edgeMode = (uint8_t *)POINTER_OF(CAM_INTF_META_EDGE, metadata);
1243    camMetadata.update(ANDROID_EDGE_MODE, edgeMode, 1);
1244
1245    uint8_t  *flashPower =
1246        (uint8_t *)POINTER_OF(CAM_INTF_META_FLASH_POWER, metadata);
1247    camMetadata.update(ANDROID_FLASH_FIRING_POWER, flashPower, 1);
1248
1249    int64_t  *flashFiringTime =
1250        (int64_t *)POINTER_OF(CAM_INTF_META_FLASH_FIRING_TIME, metadata);
1251    camMetadata.update(ANDROID_FLASH_FIRING_TIME, flashFiringTime, 1);
1252
1253    /*int32_t  *ledMode =
1254      (int32_t *)POINTER_OF(CAM_INTF_PARM_LED_MODE, metadata);
1255      camMetadata.update(ANDROID_FLASH_FIRING_TIME, ledMode, 1);*/
1256
1257    uint8_t  *flashState =
1258        (uint8_t *)POINTER_OF(CAM_INTF_META_FLASH_STATE, metadata);
1259    camMetadata.update(ANDROID_FLASH_STATE, flashState, 1);
1260
1261    uint8_t  *hotPixelMode =
1262        (uint8_t *)POINTER_OF(CAM_INTF_META_HOTPIXEL_MODE, metadata);
1263    camMetadata.update(ANDROID_HOT_PIXEL_MODE, hotPixelMode, 1);
1264
1265    float  *lensAperture =
1266        (float *)POINTER_OF(CAM_INTF_META_LENS_APERTURE, metadata);
1267    camMetadata.update(ANDROID_LENS_APERTURE , lensAperture, 1);
1268
1269    float  *filterDensity =
1270        (float *)POINTER_OF(CAM_INTF_META_LENS_FILTERDENSITY, metadata);
1271    camMetadata.update(ANDROID_LENS_FILTER_DENSITY , filterDensity, 1);
1272
1273    float  *focalLength =
1274        (float *)POINTER_OF(CAM_INTF_META_LENS_FOCAL_LENGTH, metadata);
1275    camMetadata.update(ANDROID_LENS_FOCAL_LENGTH, focalLength, 1);
1276
1277    float  *focusDistance =
1278        (float *)POINTER_OF(CAM_INTF_META_LENS_FOCUS_DISTANCE, metadata);
1279    camMetadata.update(ANDROID_LENS_FOCUS_DISTANCE , focusDistance, 1);
1280
1281    float  *focusRange =
1282        (float *)POINTER_OF(CAM_INTF_META_LENS_FOCUS_RANGE, metadata);
1283    camMetadata.update(ANDROID_LENS_FOCUS_RANGE , focusRange, 1);
1284
1285    uint8_t  *opticalStab =
1286        (uint8_t *)POINTER_OF(CAM_INTF_META_LENS_OPT_STAB_MODE, metadata);
1287    camMetadata.update(ANDROID_LENS_OPTICAL_STABILIZATION_MODE ,opticalStab, 1);
1288
1289    /*int32_t  *focusState =
1290      (int32_t *)POINTER_OF(CAM_INTF_META_LENS_FOCUS_STATE, metadata);
1291      camMetadata.update(ANDROID_LENS_STATE , focusState, 1); //check */
1292
1293    uint8_t  *noiseRedMode =
1294        (uint8_t *)POINTER_OF(CAM_INTF_META_NOISE_REDUCTION_MODE, metadata);
1295    camMetadata.update(ANDROID_NOISE_REDUCTION_MODE , noiseRedMode, 1);
1296
1297    /*CAM_INTF_META_SCALER_CROP_REGION - check size*/
1298
1299    cam_crop_region_t  *hScalerCropRegion =(cam_crop_region_t *)
1300        POINTER_OF(CAM_INTF_META_SCALER_CROP_REGION, metadata);
1301    int32_t scalerCropRegion[4];
1302    scalerCropRegion[0] = hScalerCropRegion->left;
1303    scalerCropRegion[1] = hScalerCropRegion->top;
1304    scalerCropRegion[2] = hScalerCropRegion->width;
1305    scalerCropRegion[3] = hScalerCropRegion->height;
1306    camMetadata.update(ANDROID_SCALER_CROP_REGION, scalerCropRegion, 4);
1307
1308    int64_t  *sensorExpTime =
1309        (int64_t *)POINTER_OF(CAM_INTF_META_SENSOR_EXPOSURE_TIME, metadata);
1310    camMetadata.update(ANDROID_SENSOR_EXPOSURE_TIME , sensorExpTime, 1);
1311
1312    int64_t  *sensorFameDuration =
1313        (int64_t *)POINTER_OF(CAM_INTF_META_SENSOR_FRAME_DURATION, metadata);
1314    camMetadata.update(ANDROID_SENSOR_FRAME_DURATION, sensorFameDuration, 1);
1315
1316    int32_t  *sensorSensitivity =
1317        (int32_t *)POINTER_OF(CAM_INTF_META_SENSOR_SENSITIVITY, metadata);
1318    mMetadataResponse.iso_speed = *sensorSensitivity;
1319    camMetadata.update(ANDROID_SENSOR_SENSITIVITY, sensorSensitivity, 1);
1320
1321    uint8_t  *shadingMode =
1322        (uint8_t *)POINTER_OF(CAM_INTF_META_SHADING_MODE, metadata);
1323    camMetadata.update(ANDROID_SHADING_MODE, shadingMode, 1);
1324
1325    uint8_t  *faceDetectMode =
1326        (uint8_t *)POINTER_OF(CAM_INTF_META_STATS_FACEDETECT_MODE, metadata);
1327    camMetadata.update(ANDROID_STATISTICS_FACE_DETECT_MODE, faceDetectMode, 1);
1328
1329    uint8_t  *histogramMode =
1330        (uint8_t *)POINTER_OF(CAM_INTF_META_STATS_HISTOGRAM_MODE, metadata);
1331    camMetadata.update(ANDROID_STATISTICS_HISTOGRAM_MODE, histogramMode, 1);
1332
1333    uint8_t  *sharpnessMapMode =
1334        (uint8_t *)POINTER_OF(CAM_INTF_META_STATS_SHARPNESS_MAP_MODE, metadata);
1335    camMetadata.update(ANDROID_STATISTICS_SHARPNESS_MAP_MODE,
1336            sharpnessMapMode, 1);
1337
1338    /*CAM_INTF_META_STATS_SHARPNESS_MAP - check size*/
1339    cam_sharpness_map_t  *sharpnessMap = (cam_sharpness_map_t *)
1340        POINTER_OF(CAM_INTF_META_STATS_SHARPNESS_MAP, metadata);
1341    camMetadata.update(ANDROID_STATISTICS_SHARPNESS_MAP,
1342            (int32_t*)sharpnessMap->sharpness,
1343            CAM_MAX_MAP_WIDTH*CAM_MAX_MAP_HEIGHT);
1344
1345    resultMetadata = camMetadata.release();
1346    return resultMetadata;
1347}
1348
1349/*===========================================================================
1350 * FUNCTION   : convertToRegions
1351 *
1352 * DESCRIPTION: helper method to convert from cam_rect_t into int32_t array
1353 *
1354 * PARAMETERS :
1355 *   @rect   : cam_rect_t struct to convert
1356 *   @region : int32_t destination array
1357 *   @weight : if we are converting from cam_area_t, weight is valid
1358 *             else weight = -1
1359 *
1360 *==========================================================================*/
1361void QCamera3HardwareInterface::convertToRegions(cam_rect_t rect, int32_t* region, int weight){
1362    region[0] = rect.left;
1363    region[1] = rect.top;
1364    region[2] = rect.left + rect.width;
1365    region[3] = rect.top + rect.height;
1366    if (weight > -1) {
1367        region[4] = weight;
1368    }
1369}
1370
1371/*===========================================================================
1372 * FUNCTION   : convertFromRegions
1373 *
1374 * DESCRIPTION: helper method to convert from array to cam_rect_t
1375 *
1376 * PARAMETERS :
1377 *   @rect   : cam_rect_t struct to convert
1378 *   @region : int32_t destination array
1379 *   @weight : if we are converting from cam_area_t, weight is valid
1380 *             else weight = -1
1381 *
1382 *==========================================================================*/
1383void QCamera3HardwareInterface::convertFromRegions(cam_area_t* roi,
1384                                                   const camera_metadata_t *settings,
1385                                                   uint32_t tag){
1386    CameraMetadata frame_settings;
1387    frame_settings = settings;
1388    int32_t x_min = frame_settings.find(tag).data.i32[0];
1389    int32_t y_min = frame_settings.find(tag).data.i32[1];
1390    int32_t x_max = frame_settings.find(tag).data.i32[2];
1391    int32_t y_max = frame_settings.find(tag).data.i32[3];
1392    roi->weight = frame_settings.find(tag).data.i32[4];
1393    roi->rect.left = x_min;
1394    roi->rect.top = y_min;
1395    roi->rect.width = x_max - x_min;
1396    roi->rect.height = y_max - y_min;
1397}
1398
1399/*===========================================================================
1400 * FUNCTION   : resetIfNeededROI
1401 *
1402 * DESCRIPTION: helper method to reset the roi if it is greater than scaler
1403 *              crop region
1404 *
1405 * PARAMETERS :
1406 *   @roi       : cam_area_t struct to resize
1407 *   @scalerCropRegion : cam_crop_region_t region to compare against
1408 *
1409 *
1410 *==========================================================================*/
1411bool QCamera3HardwareInterface::resetIfNeededROI(cam_area_t* roi,
1412                                                 const cam_crop_region_t* scalerCropRegion)
1413{
1414    int32_t roi_x_max = roi->rect.width + roi->rect.left;
1415    int32_t roi_y_max = roi->rect.height + roi->rect.top;
1416    int32_t crop_x_max = scalerCropRegion->width + scalerCropRegion->top;
1417    int32_t crop_y_max = scalerCropRegion->height + scalerCropRegion->left;
1418    if ((roi_x_max < scalerCropRegion->left) ||
1419        (roi_y_max < scalerCropRegion->top)  ||
1420        (roi->rect.left > crop_x_max) ||
1421        (roi->rect.top > crop_y_max)){
1422        return false;
1423    }
1424    if (roi->rect.left < scalerCropRegion->left) {
1425        roi->rect.left = scalerCropRegion->left;
1426    }
1427    if (roi->rect.top < scalerCropRegion->top) {
1428        roi->rect.top = scalerCropRegion->top;
1429    }
1430    if (roi_x_max > crop_x_max) {
1431        roi_x_max = crop_x_max;
1432    }
1433    if (roi_y_max > crop_y_max) {
1434        roi_y_max = crop_y_max;
1435    }
1436    roi->rect.width = roi_x_max - roi->rect.left;
1437    roi->rect.height = roi_y_max - roi->rect.top;
1438    return true;
1439}
1440
1441/*===========================================================================
1442 * FUNCTION   : convertLandmarks
1443 *
1444 * DESCRIPTION: helper method to extract the landmarks from face detection info
1445 *
1446 * PARAMETERS :
1447 *   @face   : cam_rect_t struct to convert
1448 *   @landmarks : int32_t destination array
1449 *
1450 *
1451 *==========================================================================*/
1452void QCamera3HardwareInterface::convertLandmarks(cam_face_detection_info_t face, int32_t* landmarks)
1453{
1454    landmarks[0] = face.left_eye_center.x;
1455    landmarks[1] = face.left_eye_center.y;
1456    landmarks[2] = face.right_eye_center.y;
1457    landmarks[3] = face.right_eye_center.y;
1458    landmarks[4] = face.mouth_center.x;
1459    landmarks[5] = face.mouth_center.y;
1460}
1461
1462#define DATA_PTR(MEM_OBJ,INDEX) MEM_OBJ->getPtr( INDEX )
1463/*===========================================================================
1464 * FUNCTION   : initCapabilities
1465 *
1466 * DESCRIPTION: initialize camera capabilities in static data struct
1467 *
1468 * PARAMETERS :
1469 *   @cameraId  : camera Id
1470 *
1471 * RETURN     : int32_t type of status
1472 *              NO_ERROR  -- success
1473 *              none-zero failure code
1474 *==========================================================================*/
1475int QCamera3HardwareInterface::initCapabilities(int cameraId)
1476{
1477    int rc = 0;
1478    mm_camera_vtbl_t *cameraHandle = NULL;
1479    QCamera3HeapMemory *capabilityHeap = NULL;
1480
1481    cameraHandle = camera_open(cameraId);
1482    if (!cameraHandle) {
1483        ALOGE("%s: camera_open failed", __func__);
1484        rc = -1;
1485        goto open_failed;
1486    }
1487
1488    capabilityHeap = new QCamera3HeapMemory();
1489    if (capabilityHeap == NULL) {
1490        ALOGE("%s: creation of capabilityHeap failed", __func__);
1491        goto heap_creation_failed;
1492    }
1493    /* Allocate memory for capability buffer */
1494    rc = capabilityHeap->allocate(1, sizeof(cam_capability_t), false);
1495    if(rc != OK) {
1496        ALOGE("%s: No memory for cappability", __func__);
1497        goto allocate_failed;
1498    }
1499
1500    /* Map memory for capability buffer */
1501    memset(DATA_PTR(capabilityHeap,0), 0, sizeof(cam_capability_t));
1502    rc = cameraHandle->ops->map_buf(cameraHandle->camera_handle,
1503                                CAM_MAPPING_BUF_TYPE_CAPABILITY,
1504                                capabilityHeap->getFd(0),
1505                                sizeof(cam_capability_t));
1506    if(rc < 0) {
1507        ALOGE("%s: failed to map capability buffer", __func__);
1508        goto map_failed;
1509    }
1510
1511    /* Query Capability */
1512    rc = cameraHandle->ops->query_capability(cameraHandle->camera_handle);
1513    if(rc < 0) {
1514        ALOGE("%s: failed to query capability",__func__);
1515        goto query_failed;
1516    }
1517    gCamCapability[cameraId] = (cam_capability_t *)malloc(sizeof(cam_capability_t));
1518    if (!gCamCapability[cameraId]) {
1519        ALOGE("%s: out of memory", __func__);
1520        goto query_failed;
1521    }
1522    memcpy(gCamCapability[cameraId], DATA_PTR(capabilityHeap,0),
1523                                        sizeof(cam_capability_t));
1524    rc = 0;
1525
1526query_failed:
1527    cameraHandle->ops->unmap_buf(cameraHandle->camera_handle,
1528                            CAM_MAPPING_BUF_TYPE_CAPABILITY);
1529map_failed:
1530    capabilityHeap->deallocate();
1531allocate_failed:
1532    delete capabilityHeap;
1533heap_creation_failed:
1534    cameraHandle->ops->close_camera(cameraHandle->camera_handle);
1535    cameraHandle = NULL;
1536open_failed:
1537    return rc;
1538}
1539
1540/*===========================================================================
1541 * FUNCTION   : initParameters
1542 *
1543 * DESCRIPTION: initialize camera parameters
1544 *
1545 * PARAMETERS :
1546 *
1547 * RETURN     : int32_t type of status
1548 *              NO_ERROR  -- success
1549 *              none-zero failure code
1550 *==========================================================================*/
1551int QCamera3HardwareInterface::initParameters()
1552{
1553    int rc = 0;
1554
1555    //Allocate Set Param Buffer
1556    mParamHeap = new QCamera3HeapMemory();
1557    rc = mParamHeap->allocate(1, sizeof(parm_buffer_t), false);
1558    if(rc != OK) {
1559        rc = NO_MEMORY;
1560        ALOGE("Failed to allocate SETPARM Heap memory");
1561        delete mParamHeap;
1562        mParamHeap = NULL;
1563        return rc;
1564    }
1565
1566    //Map memory for parameters buffer
1567    rc = mCameraHandle->ops->map_buf(mCameraHandle->camera_handle,
1568            CAM_MAPPING_BUF_TYPE_PARM_BUF,
1569            mParamHeap->getFd(0),
1570            sizeof(parm_buffer_t));
1571    if(rc < 0) {
1572        ALOGE("%s:failed to map SETPARM buffer",__func__);
1573        rc = FAILED_TRANSACTION;
1574        mParamHeap->deallocate();
1575        delete mParamHeap;
1576        mParamHeap = NULL;
1577        return rc;
1578    }
1579
1580    mParameters = (parm_buffer_t*) DATA_PTR(mParamHeap,0);
1581    return rc;
1582}
1583
1584/*===========================================================================
1585 * FUNCTION   : deinitParameters
1586 *
1587 * DESCRIPTION: de-initialize camera parameters
1588 *
1589 * PARAMETERS :
1590 *
1591 * RETURN     : NONE
1592 *==========================================================================*/
1593void QCamera3HardwareInterface::deinitParameters()
1594{
1595    mCameraHandle->ops->unmap_buf(mCameraHandle->camera_handle,
1596            CAM_MAPPING_BUF_TYPE_PARM_BUF);
1597
1598    mParamHeap->deallocate();
1599    delete mParamHeap;
1600    mParamHeap = NULL;
1601
1602    mParameters = NULL;
1603}
1604
1605/*===========================================================================
1606 * FUNCTION   : calcMaxJpegSize
1607 *
1608 * DESCRIPTION: Calculates maximum jpeg size supported by the cameraId
1609 *
1610 * PARAMETERS :
1611 *
1612 * RETURN     : max_jpeg_size
1613 *==========================================================================*/
1614int QCamera3HardwareInterface::calcMaxJpegSize()
1615{
1616    int32_t max_jpeg_size = 0;
1617    int temp_width, temp_height;
1618    for (int i = 0; i < gCamCapability[mCameraId]->picture_sizes_tbl_cnt; i++) {
1619        temp_width = gCamCapability[mCameraId]->picture_sizes_tbl[i].width;
1620        temp_height = gCamCapability[mCameraId]->picture_sizes_tbl[i].height;
1621        if (temp_width * temp_height > max_jpeg_size ) {
1622            max_jpeg_size = temp_width * temp_height;
1623        }
1624    }
1625    max_jpeg_size = max_jpeg_size * 3/2 + sizeof(camera3_jpeg_blob_t);
1626    return max_jpeg_size;
1627}
1628
1629/*===========================================================================
1630 * FUNCTION   : initStaticMetadata
1631 *
1632 * DESCRIPTION: initialize the static metadata
1633 *
1634 * PARAMETERS :
1635 *   @cameraId  : camera Id
1636 *
1637 * RETURN     : int32_t type of status
1638 *              0  -- success
1639 *              non-zero failure code
1640 *==========================================================================*/
1641int QCamera3HardwareInterface::initStaticMetadata(int cameraId)
1642{
1643    int rc = 0;
1644    CameraMetadata staticInfo;
1645    int facingBack = gCamCapability[cameraId]->position == CAM_POSITION_BACK;
1646    /*HAL 3 only*/
1647    /*staticInfo.update(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE,
1648                    &gCamCapability[cameraId]->min_focus_distance, 1); */
1649
1650    /*hard coded for now but this should come from sensor*/
1651    float min_focus_distance;
1652    if(facingBack){
1653        min_focus_distance = 10;
1654    } else {
1655        min_focus_distance = 0;
1656    }
1657    staticInfo.update(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE,
1658                    &min_focus_distance, 1);
1659
1660    staticInfo.update(ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE,
1661                    &gCamCapability[cameraId]->hyper_focal_distance, 1);
1662
1663    /*should be using focal lengths but sensor doesn't provide that info now*/
1664    staticInfo.update(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS,
1665                      &gCamCapability[cameraId]->focal_length,
1666                      1);
1667
1668    staticInfo.update(ANDROID_LENS_INFO_AVAILABLE_APERTURES,
1669                      gCamCapability[cameraId]->apertures,
1670                      gCamCapability[cameraId]->apertures_count);
1671
1672    staticInfo.update(ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES,
1673                gCamCapability[cameraId]->filter_densities,
1674                gCamCapability[cameraId]->filter_densities_count);
1675
1676
1677    staticInfo.update(ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION,
1678                      (uint8_t*)gCamCapability[cameraId]->optical_stab_modes,
1679                      gCamCapability[cameraId]->optical_stab_modes_count);
1680
1681    staticInfo.update(ANDROID_LENS_POSITION,
1682                      gCamCapability[cameraId]->lens_position,
1683                      sizeof(gCamCapability[cameraId]->lens_position)/ sizeof(float));
1684
1685    int32_t lens_shading_map_size[] = {gCamCapability[cameraId]->lens_shading_map_size.width,
1686                                                    gCamCapability[cameraId]->lens_shading_map_size.height};
1687    staticInfo.update(ANDROID_LENS_INFO_SHADING_MAP_SIZE,
1688                      lens_shading_map_size,
1689                      sizeof(lens_shading_map_size)/sizeof(int32_t));
1690
1691    staticInfo.update(ANDROID_LENS_INFO_SHADING_MAP, gCamCapability[cameraId]->lens_shading_map,
1692            sizeof(gCamCapability[cameraId]->lens_shading_map)/ sizeof(float));
1693
1694    int32_t geo_correction_map_size[] = {gCamCapability[cameraId]->geo_correction_map_size.width,
1695                                                      gCamCapability[cameraId]->geo_correction_map_size.height};
1696    staticInfo.update(ANDROID_LENS_INFO_GEOMETRIC_CORRECTION_MAP_SIZE,
1697            geo_correction_map_size,
1698            sizeof(geo_correction_map_size)/sizeof(int32_t));
1699
1700    staticInfo.update(ANDROID_LENS_INFO_GEOMETRIC_CORRECTION_MAP,
1701                       gCamCapability[cameraId]->geo_correction_map,
1702                       sizeof(gCamCapability[cameraId]->geo_correction_map)/sizeof(float));
1703
1704    staticInfo.update(ANDROID_SENSOR_INFO_PHYSICAL_SIZE,
1705            gCamCapability[cameraId]->sensor_physical_size, 2);
1706
1707    staticInfo.update(ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE,
1708            gCamCapability[cameraId]->exposure_time_range, 2);
1709
1710    staticInfo.update(ANDROID_SENSOR_INFO_MAX_FRAME_DURATION,
1711            &gCamCapability[cameraId]->max_frame_duration, 1);
1712
1713
1714    staticInfo.update(ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT,
1715                     (uint8_t*)&gCamCapability[cameraId]->color_arrangement, 1);
1716
1717    int32_t pixel_array_size[] = {gCamCapability[cameraId]->pixel_array_size.width,
1718                                               gCamCapability[cameraId]->pixel_array_size.height};
1719    staticInfo.update(ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE,
1720                      pixel_array_size, 2);
1721
1722    int32_t active_array_size[] = {gCamCapability[cameraId]->active_array_size.width,
1723                                                gCamCapability[cameraId]->active_array_size.height};
1724
1725    staticInfo.update(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE,
1726                      active_array_size, 2);
1727
1728    staticInfo.update(ANDROID_SENSOR_INFO_WHITE_LEVEL,
1729            &gCamCapability[cameraId]->white_level, 1);
1730
1731    staticInfo.update(ANDROID_SENSOR_BLACK_LEVEL_PATTERN,
1732            gCamCapability[cameraId]->black_level_pattern, 4);
1733
1734    staticInfo.update(ANDROID_FLASH_INFO_CHARGE_DURATION,
1735                      &gCamCapability[cameraId]->flash_charge_duration, 1);
1736
1737    staticInfo.update(ANDROID_TONEMAP_MAX_CURVE_POINTS,
1738                      &gCamCapability[cameraId]->max_tone_map_curve_points, 1);
1739
1740    /*staticInfo.update(ANDROID_STATISTICS_INFO_MAX_FACE_COUNT,
1741                      (int*)&gCamCapability[cameraId]->max_face_detection_count, 1);*/
1742    /*hardcode 0 for now*/
1743    int32_t max_face_count = 0;
1744    staticInfo.update(ANDROID_STATISTICS_INFO_MAX_FACE_COUNT,
1745                      &max_face_count, 1);
1746
1747    staticInfo.update(ANDROID_STATISTICS_INFO_HISTOGRAM_BUCKET_COUNT,
1748                      &gCamCapability[cameraId]->histogram_size, 1);
1749
1750    staticInfo.update(ANDROID_STATISTICS_INFO_MAX_HISTOGRAM_COUNT,
1751            &gCamCapability[cameraId]->max_histogram_count, 1);
1752
1753    int32_t sharpness_map_size[] = {gCamCapability[cameraId]->sharpness_map_size.width,
1754                                                gCamCapability[cameraId]->sharpness_map_size.height};
1755
1756    staticInfo.update(ANDROID_STATISTICS_INFO_SHARPNESS_MAP_SIZE,
1757            sharpness_map_size, sizeof(sharpness_map_size)/sizeof(int32_t));
1758
1759    staticInfo.update(ANDROID_STATISTICS_INFO_MAX_SHARPNESS_MAP_VALUE,
1760            &gCamCapability[cameraId]->max_sharpness_map_value, 1);
1761
1762
1763    staticInfo.update(ANDROID_SCALER_AVAILABLE_RAW_MIN_DURATIONS,
1764                      &gCamCapability[cameraId]->raw_min_duration,
1765                       1);
1766
1767    int32_t scalar_formats[] = {HAL_PIXEL_FORMAT_YCbCr_420_888};
1768    int scalar_formats_count = 1;
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    size = 0;
1982    int32_t avail_sensitivities[CAM_ISO_MODE_MAX];
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            avail_sensitivities[size] = sensitivity;
1987            size++;
1988        }
1989    }
1990    staticInfo.update(ANDROID_SENSOR_INFO_AVAILABLE_SENSITIVITIES,
1991                      avail_sensitivities,
1992                      size);
1993
1994    staticInfo.update(ANDROID_SENSOR_MAX_ANALOG_SENSITIVITY,
1995                      &gCamCapability[cameraId]->max_analog_sensitivity,
1996                      sizeof(int32_t) );
1997    staticInfo.update(ANDROID_SCALER_AVAILABLE_PROCESSED_MIN_DURATIONS,
1998                      &gCamCapability[cameraId]->processed_min_duration,
1999                      sizeof(int32_t));
2000    staticInfo.update(ANDROID_SCALER_AVAILABLE_JPEG_MIN_DURATIONS,
2001                      &gCamCapability[cameraId]->jpeg_min_duration,
2002                      sizeof(int32_t));
2003
2004    gStaticMetadata[cameraId] = staticInfo.release();
2005    return rc;
2006}
2007
2008/*===========================================================================
2009 * FUNCTION   : makeTable
2010 *
2011 * DESCRIPTION: make a table of sizes
2012 *
2013 * PARAMETERS :
2014 *
2015 *
2016 *==========================================================================*/
2017void QCamera3HardwareInterface::makeTable(cam_dimension_t* dimTable, uint8_t size,
2018                                          int32_t* sizeTable)
2019{
2020    int j = 0;
2021    for (int i = 0; i < size; i++) {
2022        sizeTable[j] = dimTable[i].width;
2023        sizeTable[j+1] = dimTable[i].height;
2024        j+=2;
2025    }
2026}
2027
2028/*===========================================================================
2029 * FUNCTION   : makeFPSTable
2030 *
2031 * DESCRIPTION: make a table of fps ranges
2032 *
2033 * PARAMETERS :
2034 *
2035 *==========================================================================*/
2036void QCamera3HardwareInterface::makeFPSTable(cam_fps_range_t* fpsTable, uint8_t size,
2037                                          int32_t* fpsRangesTable)
2038{
2039    int j = 0;
2040    for (int i = 0; i < size; i++) {
2041        fpsRangesTable[j] = (int32_t)fpsTable[i].min_fps;
2042        fpsRangesTable[j+1] = (int32_t)fpsTable[i].max_fps;
2043        j+=2;
2044    }
2045}
2046
2047/*===========================================================================
2048 * FUNCTION   : makeOverridesList
2049 *
2050 * DESCRIPTION: make a list of scene mode overrides
2051 *
2052 * PARAMETERS :
2053 *
2054 *
2055 *==========================================================================*/
2056void QCamera3HardwareInterface::makeOverridesList(cam_scene_mode_overrides_t* overridesTable,
2057                                                  uint8_t size, uint8_t* overridesList,
2058                                                  uint8_t* supported_indexes,
2059                                                  int camera_id)
2060{
2061    /*daemon will give a list of overrides for all scene modes.
2062      However we should send the fwk only the overrides for the scene modes
2063      supported by the framework*/
2064    int j = 0, index = 0, supt = 0;
2065    uint8_t focus_override;
2066    for (int i = 0; i < size; i++) {
2067        supt = 0;
2068        index = supported_indexes[i];
2069        overridesList[j] = (uint8_t)overridesTable[index].ae_mode;
2070        overridesList[j+1] = (uint8_t)lookupFwkName(WHITE_BALANCE_MODES_MAP,
2071                                 sizeof(WHITE_BALANCE_MODES_MAP)/sizeof(WHITE_BALANCE_MODES_MAP[0]),
2072                                                    overridesTable[index].awb_mode);
2073        focus_override = (uint8_t)overridesTable[index].af_mode;
2074        for (int k = 0; k < gCamCapability[camera_id]->supported_focus_modes_cnt; k++) {
2075           if (gCamCapability[camera_id]->supported_focus_modes[k] == focus_override) {
2076              supt = 1;
2077              break;
2078           }
2079        }
2080        if (supt) {
2081           overridesList[j+2] = (uint8_t)lookupFwkName(FOCUS_MODES_MAP,
2082                                              sizeof(FOCUS_MODES_MAP)/sizeof(FOCUS_MODES_MAP[0]),
2083                                              focus_override);
2084        } else {
2085           overridesList[j+2] = ANDROID_CONTROL_AF_MODE_OFF;
2086        }
2087        j+=3;
2088    }
2089}
2090
2091/*===========================================================================
2092 * FUNCTION   : getPreviewHalPixelFormat
2093 *
2094 * DESCRIPTION: convert the format to type recognized by framework
2095 *
2096 * PARAMETERS : format : the format from backend
2097 *
2098 ** RETURN    : format recognized by framework
2099 *
2100 *==========================================================================*/
2101int32_t QCamera3HardwareInterface::getScalarFormat(int32_t format)
2102{
2103    int32_t halPixelFormat;
2104
2105    switch (format) {
2106    case CAM_FORMAT_YUV_420_NV12:
2107        halPixelFormat = HAL_PIXEL_FORMAT_YCbCr_420_SP;
2108        break;
2109    case CAM_FORMAT_YUV_420_NV21:
2110        halPixelFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP;
2111        break;
2112    case CAM_FORMAT_YUV_420_NV21_ADRENO:
2113        halPixelFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO;
2114        break;
2115    case CAM_FORMAT_YUV_420_YV12:
2116        halPixelFormat = HAL_PIXEL_FORMAT_YV12;
2117        break;
2118    case CAM_FORMAT_YUV_422_NV16:
2119    case CAM_FORMAT_YUV_422_NV61:
2120    default:
2121        halPixelFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP;
2122        break;
2123    }
2124    return halPixelFormat;
2125}
2126
2127/*===========================================================================
2128 * FUNCTION   : getSensorSensitivity
2129 *
2130 * DESCRIPTION: convert iso_mode to an integer value
2131 *
2132 * PARAMETERS : iso_mode : the iso_mode supported by sensor
2133 *
2134 ** RETURN    : sensitivity supported by sensor
2135 *
2136 *==========================================================================*/
2137int32_t QCamera3HardwareInterface::getSensorSensitivity(int32_t iso_mode)
2138{
2139    int32_t sensitivity;
2140
2141    switch (iso_mode) {
2142    case CAM_ISO_MODE_100:
2143        sensitivity = 100;
2144        break;
2145    case CAM_ISO_MODE_200:
2146        sensitivity = 200;
2147        break;
2148    case CAM_ISO_MODE_400:
2149        sensitivity = 400;
2150        break;
2151    case CAM_ISO_MODE_800:
2152        sensitivity = 800;
2153        break;
2154    case CAM_ISO_MODE_1600:
2155        sensitivity = 1600;
2156        break;
2157    default:
2158        sensitivity = -1;
2159        break;
2160    }
2161    return sensitivity;
2162}
2163
2164
2165/*===========================================================================
2166 * FUNCTION   : AddSetParmEntryToBatch
2167 *
2168 * DESCRIPTION: add set parameter entry into batch
2169 *
2170 * PARAMETERS :
2171 *   @p_table     : ptr to parameter buffer
2172 *   @paramType   : parameter type
2173 *   @paramLength : length of parameter value
2174 *   @paramValue  : ptr to parameter value
2175 *
2176 * RETURN     : int32_t type of status
2177 *              NO_ERROR  -- success
2178 *              none-zero failure code
2179 *==========================================================================*/
2180int32_t QCamera3HardwareInterface::AddSetParmEntryToBatch(parm_buffer_t *p_table,
2181                                                          cam_intf_parm_type_t paramType,
2182                                                          uint32_t paramLength,
2183                                                          void *paramValue)
2184{
2185    int position = paramType;
2186    int current, next;
2187
2188    /*************************************************************************
2189    *                 Code to take care of linking next flags                *
2190    *************************************************************************/
2191    current = GET_FIRST_PARAM_ID(p_table);
2192    if (position == current){
2193        //DO NOTHING
2194    } else if (position < current){
2195        SET_NEXT_PARAM_ID(position, p_table, current);
2196        SET_FIRST_PARAM_ID(p_table, position);
2197    } else {
2198        /* Search for the position in the linked list where we need to slot in*/
2199        while (position > GET_NEXT_PARAM_ID(current, p_table))
2200            current = GET_NEXT_PARAM_ID(current, p_table);
2201
2202        /*If node already exists no need to alter linking*/
2203        if (position != GET_NEXT_PARAM_ID(current, p_table)) {
2204            next = GET_NEXT_PARAM_ID(current, p_table);
2205            SET_NEXT_PARAM_ID(current, p_table, position);
2206            SET_NEXT_PARAM_ID(position, p_table, next);
2207        }
2208    }
2209
2210    /*************************************************************************
2211    *                   Copy contents into entry                             *
2212    *************************************************************************/
2213
2214    if (paramLength > sizeof(parm_type_t)) {
2215        ALOGE("%s:Size of input larger than max entry size",__func__);
2216        return BAD_VALUE;
2217    }
2218    memcpy(POINTER_OF(paramType,p_table), paramValue, paramLength);
2219    return NO_ERROR;
2220}
2221
2222/*===========================================================================
2223 * FUNCTION   : lookupFwkName
2224 *
2225 * DESCRIPTION: In case the enum is not same in fwk and backend
2226 *              make sure the parameter is correctly propogated
2227 *
2228 * PARAMETERS  :
2229 *   @arr      : map between the two enums
2230 *   @len      : len of the map
2231 *   @hal_name : name of the hal_parm to map
2232 *
2233 * RETURN     : int type of status
2234 *              fwk_name  -- success
2235 *              none-zero failure code
2236 *==========================================================================*/
2237int8_t QCamera3HardwareInterface::lookupFwkName(const QCameraMap arr[],
2238                                             int len, int hal_name)
2239{
2240
2241    for (int i = 0; i < len; i++) {
2242        if (arr[i].hal_name == hal_name)
2243            return arr[i].fwk_name;
2244    }
2245
2246    /* Not able to find matching framework type is not necessarily
2247     * an error case. This happens when mm-camera supports more attributes
2248     * than the frameworks do */
2249    ALOGD("%s: Cannot find matching framework type", __func__);
2250    return NAME_NOT_FOUND;
2251}
2252
2253/*===========================================================================
2254 * FUNCTION   : lookupHalName
2255 *
2256 * DESCRIPTION: In case the enum is not same in fwk and backend
2257 *              make sure the parameter is correctly propogated
2258 *
2259 * PARAMETERS  :
2260 *   @arr      : map between the two enums
2261 *   @len      : len of the map
2262 *   @fwk_name : name of the hal_parm to map
2263 *
2264 * RETURN     : int32_t type of status
2265 *              hal_name  -- success
2266 *              none-zero failure code
2267 *==========================================================================*/
2268int8_t QCamera3HardwareInterface::lookupHalName(const QCameraMap arr[],
2269                                             int len, int fwk_name)
2270{
2271    for (int i = 0; i < len; i++) {
2272       if (arr[i].fwk_name == fwk_name)
2273           return arr[i].hal_name;
2274    }
2275    ALOGE("%s: Cannot find matching hal type", __func__);
2276    return NAME_NOT_FOUND;
2277}
2278
2279/*===========================================================================
2280 * FUNCTION   : getCapabilities
2281 *
2282 * DESCRIPTION: query camera capabilities
2283 *
2284 * PARAMETERS :
2285 *   @cameraId  : camera Id
2286 *   @info      : camera info struct to be filled in with camera capabilities
2287 *
2288 * RETURN     : int32_t type of status
2289 *              NO_ERROR  -- success
2290 *              none-zero failure code
2291 *==========================================================================*/
2292int QCamera3HardwareInterface::getCamInfo(int cameraId,
2293                                    struct camera_info *info)
2294{
2295    int rc = 0;
2296
2297    if (NULL == gCamCapability[cameraId]) {
2298        rc = initCapabilities(cameraId);
2299        if (rc < 0) {
2300            //pthread_mutex_unlock(&g_camlock);
2301            return rc;
2302        }
2303    }
2304
2305    if (NULL == gStaticMetadata[cameraId]) {
2306        rc = initStaticMetadata(cameraId);
2307        if (rc < 0) {
2308            return rc;
2309        }
2310    }
2311
2312    switch(gCamCapability[cameraId]->position) {
2313    case CAM_POSITION_BACK:
2314        info->facing = CAMERA_FACING_BACK;
2315        break;
2316
2317    case CAM_POSITION_FRONT:
2318        info->facing = CAMERA_FACING_FRONT;
2319        break;
2320
2321    default:
2322        ALOGE("%s:Unknown position type for camera id:%d", __func__, cameraId);
2323        rc = -1;
2324        break;
2325    }
2326
2327
2328    info->orientation = gCamCapability[cameraId]->sensor_mount_angle;
2329    info->device_version = HARDWARE_DEVICE_API_VERSION(3, 0);
2330    info->static_camera_characteristics = gStaticMetadata[cameraId];
2331
2332    return rc;
2333}
2334
2335/*===========================================================================
2336 * FUNCTION   : translateMetadata
2337 *
2338 * DESCRIPTION: translate the metadata into camera_metadata_t
2339 *
2340 * PARAMETERS : type of the request
2341 *
2342 *
2343 * RETURN     : success: camera_metadata_t*
2344 *              failure: NULL
2345 *
2346 *==========================================================================*/
2347camera_metadata_t* QCamera3HardwareInterface::translateCapabilityToMetadata(int type)
2348{
2349    pthread_mutex_lock(&mMutex);
2350
2351    if (mDefaultMetadata[type] != NULL) {
2352        pthread_mutex_unlock(&mMutex);
2353        return mDefaultMetadata[type];
2354    }
2355    //first time we are handling this request
2356    //fill up the metadata structure using the wrapper class
2357    CameraMetadata settings;
2358    //translate from cam_capability_t to camera_metadata_tag_t
2359    static const uint8_t requestType = ANDROID_REQUEST_TYPE_CAPTURE;
2360    settings.update(ANDROID_REQUEST_TYPE, &requestType, 1);
2361
2362    /*control*/
2363
2364    uint8_t controlIntent = 0;
2365    switch (type) {
2366      case CAMERA3_TEMPLATE_PREVIEW:
2367        controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW;
2368        break;
2369      case CAMERA3_TEMPLATE_STILL_CAPTURE:
2370        controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE;
2371        break;
2372      case CAMERA3_TEMPLATE_VIDEO_RECORD:
2373        controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_RECORD;
2374        break;
2375      case CAMERA3_TEMPLATE_VIDEO_SNAPSHOT:
2376        controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT;
2377        break;
2378      case CAMERA3_TEMPLATE_ZERO_SHUTTER_LAG:
2379        controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_ZERO_SHUTTER_LAG;
2380        break;
2381      default:
2382        controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_CUSTOM;
2383        break;
2384    }
2385    settings.update(ANDROID_CONTROL_CAPTURE_INTENT, &controlIntent, 1);
2386
2387    settings.update(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION,
2388            &gCamCapability[mCameraId]->exposure_compensation_default, 1);
2389
2390    static const uint8_t aeLock = ANDROID_CONTROL_AE_LOCK_OFF;
2391    settings.update(ANDROID_CONTROL_AE_LOCK, &aeLock, 1);
2392
2393    static const uint8_t awbLock = ANDROID_CONTROL_AWB_LOCK_OFF;
2394    settings.update(ANDROID_CONTROL_AWB_LOCK, &awbLock, 1);
2395
2396    static const uint8_t awbMode = ANDROID_CONTROL_AWB_MODE_AUTO;
2397    settings.update(ANDROID_CONTROL_AWB_MODE, &awbMode, 1);
2398
2399    static const uint8_t controlMode = ANDROID_CONTROL_MODE_AUTO;
2400    settings.update(ANDROID_CONTROL_MODE, &controlMode, 1);
2401
2402    static const uint8_t effectMode = ANDROID_CONTROL_EFFECT_MODE_OFF;
2403    settings.update(ANDROID_CONTROL_EFFECT_MODE, &effectMode, 1);
2404
2405    static const uint8_t sceneMode = ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY; //similar to AUTO?
2406    settings.update(ANDROID_CONTROL_SCENE_MODE, &sceneMode, 1);
2407
2408    static uint8_t focusMode;
2409    if (gCamCapability[mCameraId]->supported_focus_modes_cnt > 1) {
2410        ALOGE("%s: Setting focus mode to auto", __func__);
2411        focusMode = ANDROID_CONTROL_AF_MODE_AUTO;
2412    } else {
2413        ALOGE("%s: Setting focus mode to off", __func__);
2414        focusMode = ANDROID_CONTROL_AF_MODE_OFF;
2415    }
2416    settings.update(ANDROID_CONTROL_AF_MODE, &focusMode, 1);
2417
2418    static const uint8_t aeMode = ANDROID_CONTROL_AE_MODE_ON;
2419    settings.update(ANDROID_CONTROL_AE_MODE, &aeMode, 1);
2420
2421    /*flash*/
2422    static const uint8_t flashMode = ANDROID_FLASH_MODE_OFF;
2423    settings.update(ANDROID_FLASH_MODE, &flashMode, 1);
2424
2425
2426    /* lens */
2427    float default_aperture = gCamCapability[mCameraId]->apertures[0];
2428    settings.update(ANDROID_LENS_APERTURE, &default_aperture, 1);
2429
2430    if (gCamCapability[mCameraId]->filter_densities_count) {
2431        float default_filter_density = gCamCapability[mCameraId]->filter_densities[0];
2432        settings.update(ANDROID_LENS_FILTER_DENSITY, &default_filter_density,
2433                        gCamCapability[mCameraId]->filter_densities_count);
2434    }
2435
2436    float default_focal_length = gCamCapability[mCameraId]->focal_length;
2437    settings.update(ANDROID_LENS_FOCAL_LENGTH, &default_focal_length, 1);
2438
2439    mDefaultMetadata[type] = settings.release();
2440
2441    pthread_mutex_unlock(&mMutex);
2442    return mDefaultMetadata[type];
2443}
2444
2445/*===========================================================================
2446 * FUNCTION   : setFrameParameters
2447 *
2448 * DESCRIPTION: set parameters per frame as requested in the metadata from
2449 *              framework
2450 *
2451 * PARAMETERS :
2452 *   @settings  : frame settings information from framework
2453 *
2454 *
2455 * RETURN     : success: NO_ERROR
2456 *              failure:
2457 *==========================================================================*/
2458int QCamera3HardwareInterface::setFrameParameters(int frame_id,
2459                                                  const camera_metadata_t *settings)
2460{
2461    /*translate from camera_metadata_t type to parm_type_t*/
2462    int rc = 0;
2463    if (settings == NULL && mFirstRequest) {
2464        /*settings cannot be null for the first request*/
2465        return BAD_VALUE;
2466    }
2467
2468    int32_t hal_version = CAM_HAL_V3;
2469
2470    memset(mParameters, 0, sizeof(parm_buffer_t));
2471    mParameters->first_flagged_entry = CAM_INTF_PARM_MAX;
2472    AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_HAL_VERSION,
2473                sizeof(hal_version), &hal_version);
2474
2475    /*we need to update the frame number in the parameters*/
2476    rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_FRAME_NUMBER,
2477                                sizeof(frame_id), &frame_id);
2478    if (rc < 0) {
2479        ALOGE("%s: Failed to set the frame number in the parameters", __func__);
2480        return BAD_VALUE;
2481    }
2482
2483    if(settings != NULL){
2484        rc = translateMetadataToParameters(settings);
2485    }
2486    /*set the parameters to backend*/
2487    mCameraHandle->ops->set_parms(mCameraHandle->camera_handle, mParameters);
2488    return rc;
2489}
2490
2491/*===========================================================================
2492 * FUNCTION   : translateMetadataToParameters
2493 *
2494 * DESCRIPTION: read from the camera_metadata_t and change to parm_type_t
2495 *
2496 *
2497 * PARAMETERS :
2498 *   @settings  : frame settings information from framework
2499 *
2500 *
2501 * RETURN     : success: NO_ERROR
2502 *              failure:
2503 *==========================================================================*/
2504int QCamera3HardwareInterface::translateMetadataToParameters
2505                                  (const camera_metadata_t *settings)
2506{
2507    int rc = 0;
2508    CameraMetadata frame_settings;
2509    frame_settings = settings;
2510
2511
2512    if (frame_settings.exists(ANDROID_CONTROL_AE_ANTIBANDING_MODE)) {
2513        int32_t antibandingMode =
2514            frame_settings.find(ANDROID_CONTROL_AE_ANTIBANDING_MODE).data.i32[0];
2515        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_ANTIBANDING,
2516                sizeof(antibandingMode), &antibandingMode);
2517    }
2518
2519    if (frame_settings.exists(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION)) {
2520        int32_t expCompensation = frame_settings.find(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION).data.i32[0];
2521        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_EXPOSURE_COMPENSATION,
2522          sizeof(expCompensation), &expCompensation);
2523    }
2524
2525    if (frame_settings.exists(ANDROID_CONTROL_AE_LOCK)) {
2526        uint8_t aeLock = frame_settings.find(ANDROID_CONTROL_AE_LOCK).data.u8[0];
2527        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_AEC_LOCK,
2528                sizeof(aeLock), &aeLock);
2529    }
2530
2531    if (frame_settings.exists(ANDROID_CONTROL_AE_TARGET_FPS_RANGE)) {
2532        cam_fps_range_t fps_range;
2533        fps_range.min_fps =
2534            frame_settings.find(ANDROID_CONTROL_AE_TARGET_FPS_RANGE).data.i32[0];
2535        fps_range.max_fps =
2536            frame_settings.find(ANDROID_CONTROL_AE_TARGET_FPS_RANGE).data.i32[1];
2537        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_FPS_RANGE,
2538                sizeof(fps_range), &fps_range);
2539    }
2540
2541    float focalDistance = -1.0;
2542    if (frame_settings.exists(ANDROID_LENS_FOCUS_DISTANCE)) {
2543        focalDistance = frame_settings.find(ANDROID_LENS_FOCUS_DISTANCE).data.f[0];
2544        rc = AddSetParmEntryToBatch(mParameters,
2545                CAM_INTF_META_LENS_FOCUS_DISTANCE,
2546                sizeof(focalDistance), &focalDistance);
2547    }
2548
2549    if (frame_settings.exists(ANDROID_CONTROL_AF_MODE)) {
2550        uint8_t fwk_focusMode =
2551            frame_settings.find(ANDROID_CONTROL_AF_MODE).data.u8[0];
2552        uint8_t focusMode;
2553        if (focalDistance == 0.0 && fwk_focusMode == ANDROID_CONTROL_AF_MODE_OFF) {
2554            focusMode = CAM_FOCUS_MODE_INFINITY;
2555        } else{
2556         focusMode = lookupHalName(FOCUS_MODES_MAP,
2557                                   sizeof(FOCUS_MODES_MAP),
2558                                   fwk_focusMode);
2559        }
2560        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_FOCUS_MODE,
2561                sizeof(focusMode), &focusMode);
2562    }
2563
2564    if (frame_settings.exists(ANDROID_CONTROL_AWB_LOCK)) {
2565        uint8_t awbLock =
2566            frame_settings.find(ANDROID_CONTROL_AWB_LOCK).data.u8[0];
2567        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_AWB_LOCK,
2568                sizeof(awbLock), &awbLock);
2569    }
2570
2571    if (frame_settings.exists(ANDROID_CONTROL_AWB_MODE)) {
2572        uint8_t fwk_whiteLevel =
2573            frame_settings.find(ANDROID_CONTROL_AWB_MODE).data.u8[0];
2574        uint8_t whiteLevel = lookupHalName(WHITE_BALANCE_MODES_MAP,
2575                sizeof(WHITE_BALANCE_MODES_MAP),
2576                fwk_whiteLevel);
2577        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_WHITE_BALANCE,
2578                sizeof(whiteLevel), &whiteLevel);
2579    }
2580
2581    if (frame_settings.exists(ANDROID_CONTROL_EFFECT_MODE)) {
2582        uint8_t fwk_effectMode =
2583            frame_settings.find(ANDROID_CONTROL_EFFECT_MODE).data.u8[0];
2584        uint8_t effectMode = lookupHalName(EFFECT_MODES_MAP,
2585                sizeof(EFFECT_MODES_MAP),
2586                fwk_effectMode);
2587        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_EFFECT,
2588                sizeof(effectMode), &effectMode);
2589    }
2590
2591    if (frame_settings.exists(ANDROID_CONTROL_AE_MODE)) {
2592        uint8_t fwk_aeMode =
2593            frame_settings.find(ANDROID_CONTROL_AE_MODE).data.u8[0];
2594        uint8_t aeMode;
2595        int32_t redeye;
2596        if (fwk_aeMode == ANDROID_CONTROL_AE_MODE_OFF ) {
2597            aeMode = CAM_AE_MODE_OFF;
2598        } else {
2599            aeMode = CAM_AE_MODE_ON;
2600        }
2601        if (fwk_aeMode == ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE) {
2602            redeye = 1;
2603        } else {
2604            redeye = 0;
2605        }
2606        int32_t flashMode = (int32_t)lookupHalName(AE_FLASH_MODE_MAP,
2607                                          sizeof(AE_FLASH_MODE_MAP),
2608                                          fwk_aeMode);
2609        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_AEC_MODE,
2610                sizeof(aeMode), &aeMode);
2611        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_LED_MODE,
2612                sizeof(flashMode), &flashMode);
2613        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_REDEYE_REDUCTION,
2614                sizeof(redeye), &redeye);
2615    }
2616
2617    if (frame_settings.exists(ANDROID_REQUEST_FRAME_COUNT)) {
2618        int32_t metaFrameNumber =
2619            frame_settings.find(ANDROID_REQUEST_FRAME_COUNT).data.i32[0];
2620        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_FRAME_NUMBER,
2621                sizeof(metaFrameNumber), &metaFrameNumber);
2622    }
2623
2624    if (frame_settings.exists(ANDROID_COLOR_CORRECTION_MODE)) {
2625        uint8_t colorCorrectMode =
2626            frame_settings.find(ANDROID_COLOR_CORRECTION_MODE).data.u8[0];
2627        rc =
2628            AddSetParmEntryToBatch(mParameters, CAM_INTF_META_COLOR_CORRECT_MODE,
2629                    sizeof(colorCorrectMode), &colorCorrectMode);
2630    }
2631    cam_trigger_t aecTrigger;
2632    aecTrigger.trigger = CAM_AEC_TRIGGER_IDLE;
2633    aecTrigger.trigger_id = -1;
2634    if (frame_settings.exists(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER)&&
2635        frame_settings.exists(ANDROID_CONTROL_AE_PRECAPTURE_ID)) {
2636        aecTrigger.trigger =
2637            frame_settings.find(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER).data.u8[0];
2638        aecTrigger.trigger_id =
2639            frame_settings.find(ANDROID_CONTROL_AE_PRECAPTURE_ID).data.i32[0];
2640    }
2641    rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_AEC_PRECAPTURE_TRIGGER,
2642                                sizeof(aecTrigger), &aecTrigger);
2643
2644    /*af_trigger must come with a trigger id*/
2645    if (frame_settings.exists(ANDROID_CONTROL_AF_TRIGGER) &&
2646        frame_settings.exists(ANDROID_CONTROL_AF_TRIGGER_ID)) {
2647        cam_trigger_t af_trigger;
2648        af_trigger.trigger =
2649            frame_settings.find(ANDROID_CONTROL_AF_TRIGGER).data.u8[0];
2650        af_trigger.trigger_id =
2651            frame_settings.find(ANDROID_CONTROL_AF_TRIGGER_ID).data.i32[0];
2652        rc = AddSetParmEntryToBatch(mParameters,
2653                CAM_INTF_META_AF_TRIGGER, sizeof(af_trigger), &af_trigger);
2654    }
2655
2656    if (frame_settings.exists(ANDROID_CONTROL_MODE)) {
2657        uint8_t metaMode = frame_settings.find(ANDROID_CONTROL_MODE).data.u8[0];
2658        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_MODE,
2659                sizeof(metaMode), &metaMode);
2660        if (metaMode == ANDROID_CONTROL_MODE_USE_SCENE_MODE) {
2661           uint8_t fwk_sceneMode = frame_settings.find(ANDROID_CONTROL_SCENE_MODE).data.u8[0];
2662           uint8_t sceneMode = lookupHalName(SCENE_MODES_MAP,
2663                                             sizeof(SCENE_MODES_MAP)/sizeof(SCENE_MODES_MAP[0]),
2664                                             fwk_sceneMode);
2665           rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_BESTSHOT_MODE,
2666                sizeof(sceneMode), &sceneMode);
2667        } else if (metaMode == ANDROID_CONTROL_MODE_OFF) {
2668           uint8_t sceneMode = 0;//CAMERA_BESTSHOT_OFF;
2669           rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_BESTSHOT_MODE,
2670                sizeof(sceneMode), &sceneMode);
2671        } else if (metaMode == ANDROID_CONTROL_MODE_AUTO) {
2672           uint8_t sceneMode = 0;//CAMERA_BESTSHOT_OFF;
2673           rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_BESTSHOT_MODE,
2674                sizeof(sceneMode), &sceneMode);
2675        }
2676    }
2677
2678    if (frame_settings.exists(ANDROID_DEMOSAIC_MODE)) {
2679        int32_t demosaic =
2680            frame_settings.find(ANDROID_DEMOSAIC_MODE).data.u8[0];
2681        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_DEMOSAIC,
2682                sizeof(demosaic), &demosaic);
2683    }
2684
2685    if (frame_settings.exists(ANDROID_EDGE_MODE)) {
2686        uint8_t edgeMode = frame_settings.find(ANDROID_EDGE_MODE).data.u8[0];
2687        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_EDGE,
2688                sizeof(edgeMode), &edgeMode);
2689    }
2690
2691    if (frame_settings.exists(ANDROID_EDGE_STRENGTH)) {
2692        int32_t edgeStrength =
2693            frame_settings.find(ANDROID_EDGE_STRENGTH).data.i32[0];
2694        rc = AddSetParmEntryToBatch(mParameters,
2695                CAM_INTF_META_SHARPNESS_STRENGTH, sizeof(edgeStrength), &edgeStrength);
2696    }
2697
2698    if (frame_settings.exists(ANDROID_FLASH_MODE)) {
2699        uint8_t flashMode =
2700            frame_settings.find(ANDROID_FLASH_MODE).data.u8[0];
2701        rc = AddSetParmEntryToBatch(mParameters,
2702                CAM_INTF_META_FLASH_MODE, sizeof(flashMode), &flashMode);
2703    }
2704
2705    if (frame_settings.exists(ANDROID_FLASH_FIRING_POWER)) {
2706        uint8_t flashPower =
2707            frame_settings.find(ANDROID_FLASH_FIRING_POWER).data.u8[0];
2708        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_FLASH_POWER,
2709                sizeof(flashPower), &flashPower);
2710    }
2711
2712    if (frame_settings.exists(ANDROID_FLASH_FIRING_TIME)) {
2713        int64_t flashFiringTime =
2714            frame_settings.find(ANDROID_FLASH_FIRING_TIME).data.i64[0];
2715        rc = AddSetParmEntryToBatch(mParameters,
2716                CAM_INTF_META_FLASH_FIRING_TIME, sizeof(flashFiringTime), &flashFiringTime);
2717    }
2718
2719    if (frame_settings.exists(ANDROID_GEOMETRIC_MODE)) {
2720        uint8_t geometricMode =
2721            frame_settings.find(ANDROID_GEOMETRIC_MODE).data.u8[0];
2722        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_GEOMETRIC_MODE,
2723                sizeof(geometricMode), &geometricMode);
2724    }
2725
2726    if (frame_settings.exists(ANDROID_GEOMETRIC_STRENGTH)) {
2727        uint8_t geometricStrength =
2728            frame_settings.find(ANDROID_GEOMETRIC_STRENGTH).data.u8[0];
2729        rc = AddSetParmEntryToBatch(mParameters,
2730                CAM_INTF_META_GEOMETRIC_STRENGTH,
2731                sizeof(geometricStrength), &geometricStrength);
2732    }
2733
2734    if (frame_settings.exists(ANDROID_HOT_PIXEL_MODE)) {
2735        uint8_t hotPixelMode =
2736            frame_settings.find(ANDROID_HOT_PIXEL_MODE).data.u8[0];
2737        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_HOTPIXEL_MODE,
2738                sizeof(hotPixelMode), &hotPixelMode);
2739    }
2740
2741    if (frame_settings.exists(ANDROID_LENS_APERTURE)) {
2742        float lensAperture =
2743            frame_settings.find( ANDROID_LENS_APERTURE).data.f[0];
2744        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_LENS_APERTURE,
2745                sizeof(lensAperture), &lensAperture);
2746    }
2747
2748    if (frame_settings.exists(ANDROID_LENS_FILTER_DENSITY)) {
2749        float filterDensity =
2750            frame_settings.find(ANDROID_LENS_FILTER_DENSITY).data.f[0];
2751        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_LENS_FILTERDENSITY,
2752                sizeof(filterDensity), &filterDensity);
2753    }
2754
2755    if (frame_settings.exists(ANDROID_LENS_FOCAL_LENGTH)) {
2756        float focalLength =
2757            frame_settings.find(ANDROID_LENS_FOCAL_LENGTH).data.f[0];
2758        rc = AddSetParmEntryToBatch(mParameters,
2759                CAM_INTF_META_LENS_FOCAL_LENGTH,
2760                sizeof(focalLength), &focalLength);
2761    }
2762
2763    if (frame_settings.exists(ANDROID_LENS_OPTICAL_STABILIZATION_MODE)) {
2764        uint8_t optStabMode =
2765            frame_settings.find(ANDROID_LENS_OPTICAL_STABILIZATION_MODE).data.u8[0];
2766        rc = AddSetParmEntryToBatch(mParameters,
2767                CAM_INTF_META_LENS_OPT_STAB_MODE,
2768                sizeof(optStabMode), &optStabMode);
2769    }
2770
2771    if (frame_settings.exists(ANDROID_NOISE_REDUCTION_MODE)) {
2772        uint8_t noiseRedMode =
2773            frame_settings.find(ANDROID_NOISE_REDUCTION_MODE).data.u8[0];
2774        rc = AddSetParmEntryToBatch(mParameters,
2775                CAM_INTF_META_NOISE_REDUCTION_MODE,
2776                sizeof(noiseRedMode), &noiseRedMode);
2777    }
2778
2779    if (frame_settings.exists(ANDROID_NOISE_REDUCTION_STRENGTH)) {
2780        uint8_t noiseRedStrength =
2781            frame_settings.find(ANDROID_NOISE_REDUCTION_STRENGTH).data.u8[0];
2782        rc = AddSetParmEntryToBatch(mParameters,
2783                CAM_INTF_META_NOISE_REDUCTION_STRENGTH,
2784                sizeof(noiseRedStrength), &noiseRedStrength);
2785    }
2786
2787    cam_crop_region_t scalerCropRegion;
2788    bool scalerCropSet = false;
2789    if (frame_settings.exists(ANDROID_SCALER_CROP_REGION)) {
2790        scalerCropRegion.left =
2791            frame_settings.find(ANDROID_SCALER_CROP_REGION).data.i32[0];
2792        scalerCropRegion.top =
2793            frame_settings.find(ANDROID_SCALER_CROP_REGION).data.i32[1];
2794        scalerCropRegion.width =
2795            frame_settings.find(ANDROID_SCALER_CROP_REGION).data.i32[2];
2796        scalerCropRegion.height =
2797            frame_settings.find(ANDROID_SCALER_CROP_REGION).data.i32[3];
2798        rc = AddSetParmEntryToBatch(mParameters,
2799                CAM_INTF_META_SCALER_CROP_REGION,
2800                sizeof(scalerCropRegion), &scalerCropRegion);
2801        scalerCropSet = true;
2802    }
2803
2804    if (frame_settings.exists(ANDROID_SENSOR_EXPOSURE_TIME)) {
2805        int64_t sensorExpTime =
2806            frame_settings.find(ANDROID_SENSOR_EXPOSURE_TIME).data.i64[0];
2807        rc = AddSetParmEntryToBatch(mParameters,
2808                CAM_INTF_META_SENSOR_EXPOSURE_TIME,
2809                sizeof(sensorExpTime), &sensorExpTime);
2810    }
2811
2812    if (frame_settings.exists(ANDROID_SENSOR_FRAME_DURATION)) {
2813        int64_t sensorFrameDuration =
2814            frame_settings.find(ANDROID_SENSOR_FRAME_DURATION).data.i64[0];
2815        rc = AddSetParmEntryToBatch(mParameters,
2816                CAM_INTF_META_SENSOR_FRAME_DURATION,
2817                sizeof(sensorFrameDuration), &sensorFrameDuration);
2818    }
2819
2820    if (frame_settings.exists(ANDROID_SENSOR_SENSITIVITY)) {
2821        int32_t sensorSensitivity =
2822            frame_settings.find(ANDROID_SENSOR_SENSITIVITY).data.i32[0];
2823        rc = AddSetParmEntryToBatch(mParameters,
2824                CAM_INTF_META_SENSOR_SENSITIVITY,
2825                sizeof(sensorSensitivity), &sensorSensitivity);
2826    }
2827
2828    if (frame_settings.exists(ANDROID_SHADING_MODE)) {
2829        int32_t shadingMode =
2830            frame_settings.find(ANDROID_SHADING_MODE).data.u8[0];
2831        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_SHADING_MODE,
2832                sizeof(shadingMode), &shadingMode);
2833    }
2834
2835    if (frame_settings.exists(ANDROID_SHADING_STRENGTH)) {
2836        uint8_t shadingStrength =
2837            frame_settings.find(ANDROID_SHADING_STRENGTH).data.u8[0];
2838        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_SHADING_STRENGTH,
2839                sizeof(shadingStrength), &shadingStrength);
2840    }
2841
2842    if (frame_settings.exists(ANDROID_STATISTICS_FACE_DETECT_MODE)) {
2843        uint8_t facedetectMode =
2844            frame_settings.find(ANDROID_STATISTICS_FACE_DETECT_MODE).data.u8[0];
2845        rc = AddSetParmEntryToBatch(mParameters,
2846                CAM_INTF_META_STATS_FACEDETECT_MODE,
2847                sizeof(facedetectMode), &facedetectMode);
2848    }
2849
2850    if (frame_settings.exists(ANDROID_STATISTICS_HISTOGRAM_MODE)) {
2851        uint8_t histogramMode =
2852            frame_settings.find(ANDROID_STATISTICS_HISTOGRAM_MODE).data.u8[0];
2853        rc = AddSetParmEntryToBatch(mParameters,
2854                CAM_INTF_META_STATS_HISTOGRAM_MODE,
2855                sizeof(histogramMode), &histogramMode);
2856    }
2857
2858    if (frame_settings.exists(ANDROID_STATISTICS_SHARPNESS_MAP_MODE)) {
2859        uint8_t sharpnessMapMode =
2860            frame_settings.find(ANDROID_STATISTICS_SHARPNESS_MAP_MODE).data.u8[0];
2861        rc = AddSetParmEntryToBatch(mParameters,
2862                CAM_INTF_META_STATS_SHARPNESS_MAP_MODE,
2863                sizeof(sharpnessMapMode), &sharpnessMapMode);
2864    }
2865
2866    if (frame_settings.exists(ANDROID_TONEMAP_MODE)) {
2867        uint8_t tonemapMode =
2868            frame_settings.find(ANDROID_TONEMAP_MODE).data.u8[0];
2869        rc = AddSetParmEntryToBatch(mParameters,
2870                CAM_INTF_META_TONEMAP_MODE,
2871                sizeof(tonemapMode), &tonemapMode);
2872    }
2873
2874    if (frame_settings.exists(ANDROID_CONTROL_CAPTURE_INTENT)) {
2875        uint8_t captureIntent =
2876            frame_settings.find(ANDROID_CONTROL_CAPTURE_INTENT).data.u8[0];
2877        rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_CAPTURE_INTENT,
2878                sizeof(captureIntent), &captureIntent);
2879    }
2880
2881    if (frame_settings.exists(ANDROID_CONTROL_AE_REGIONS)) {
2882        cam_area_t roi;
2883        bool reset = true;
2884        convertFromRegions(&roi, settings, ANDROID_CONTROL_AE_REGIONS);
2885        if (scalerCropSet) {
2886            reset = resetIfNeededROI(&roi, &scalerCropRegion);
2887        }
2888        if (reset) {
2889            rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_AEC_ROI,
2890                    sizeof(roi), &roi);
2891        }
2892    }
2893
2894    if (frame_settings.exists(ANDROID_CONTROL_AF_REGIONS)) {
2895        cam_area_t roi;
2896        bool reset = true;
2897        convertFromRegions(&roi, settings, ANDROID_CONTROL_AF_REGIONS);
2898        if (scalerCropSet) {
2899            reset = resetIfNeededROI(&roi, &scalerCropRegion);
2900        }
2901        if (reset) {
2902            rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_AF_ROI,
2903                    sizeof(roi), &roi);
2904        }
2905    }
2906
2907    if (frame_settings.exists(ANDROID_CONTROL_AWB_REGIONS)) {
2908        cam_area_t roi;
2909        bool reset = true;
2910        convertFromRegions(&roi, settings, ANDROID_CONTROL_AWB_REGIONS);
2911        if (scalerCropSet) {
2912            reset = resetIfNeededROI(&roi, &scalerCropRegion);
2913        }
2914        if (reset) {
2915            rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_AWB_REGIONS,
2916                    sizeof(roi), &roi);
2917        }
2918    }
2919    return rc;
2920}
2921
2922/*===========================================================================
2923 * FUNCTION   : getJpegSettings
2924 *
2925 * DESCRIPTION: save the jpeg settings in the HAL
2926 *
2927 *
2928 * PARAMETERS :
2929 *   @settings  : frame settings information from framework
2930 *
2931 *
2932 * RETURN     : success: NO_ERROR
2933 *              failure:
2934 *==========================================================================*/
2935int QCamera3HardwareInterface::getJpegSettings
2936                                  (const camera_metadata_t *settings)
2937{
2938    if (mJpegSettings) {
2939        if (mJpegSettings->gps_timestamp) {
2940            free(mJpegSettings->gps_timestamp);
2941            mJpegSettings->gps_timestamp = NULL;
2942        }
2943        if (mJpegSettings->gps_coordinates) {
2944            for (int i = 0; i < 3; i++) {
2945                free(mJpegSettings->gps_coordinates[i]);
2946                mJpegSettings->gps_coordinates[i] = NULL;
2947            }
2948        }
2949        free(mJpegSettings);
2950        mJpegSettings = NULL;
2951    }
2952    mJpegSettings = (jpeg_settings_t*) malloc(sizeof(jpeg_settings_t));
2953    CameraMetadata jpeg_settings;
2954    jpeg_settings = settings;
2955
2956    if (jpeg_settings.exists(ANDROID_JPEG_ORIENTATION)) {
2957        mJpegSettings->jpeg_orientation =
2958            jpeg_settings.find(ANDROID_JPEG_ORIENTATION).data.i32[0];
2959    } else {
2960        mJpegSettings->jpeg_orientation = 0;
2961    }
2962    if (jpeg_settings.exists(ANDROID_JPEG_QUALITY)) {
2963        mJpegSettings->jpeg_quality =
2964            jpeg_settings.find(ANDROID_JPEG_QUALITY).data.u8[0];
2965    } else {
2966        mJpegSettings->jpeg_quality = 85;
2967    }
2968    if (jpeg_settings.exists(ANDROID_JPEG_THUMBNAIL_SIZE)) {
2969        mJpegSettings->thumbnail_size.width =
2970            jpeg_settings.find(ANDROID_JPEG_THUMBNAIL_SIZE).data.i32[0];
2971        mJpegSettings->thumbnail_size.height =
2972            jpeg_settings.find(ANDROID_JPEG_THUMBNAIL_SIZE).data.i32[1];
2973    } else {
2974        mJpegSettings->thumbnail_size.width = 0;
2975        mJpegSettings->thumbnail_size.height = 0;
2976    }
2977    if (jpeg_settings.exists(ANDROID_JPEG_GPS_COORDINATES)) {
2978        for (int i = 0; i < 3; i++) {
2979            mJpegSettings->gps_coordinates[i] = (double*)malloc(sizeof(double*));
2980            *(mJpegSettings->gps_coordinates[i]) =
2981                jpeg_settings.find(ANDROID_JPEG_GPS_COORDINATES).data.d[i];
2982        }
2983    } else{
2984       for (int i = 0; i < 3; i++) {
2985            mJpegSettings->gps_coordinates[i] = NULL;
2986        }
2987    }
2988
2989    if (jpeg_settings.exists(ANDROID_JPEG_GPS_TIMESTAMP)) {
2990        mJpegSettings->gps_timestamp = (int64_t*)malloc(sizeof(int64_t*));
2991        *(mJpegSettings->gps_timestamp) =
2992            jpeg_settings.find(ANDROID_JPEG_GPS_TIMESTAMP).data.i64[0];
2993    } else {
2994        mJpegSettings->gps_timestamp = NULL;
2995    }
2996
2997    if (jpeg_settings.exists(ANDROID_JPEG_GPS_PROCESSING_METHOD)) {
2998        int len = jpeg_settings.find(ANDROID_JPEG_GPS_PROCESSING_METHOD).count;
2999        for (int i = 0; i < len; i++) {
3000            mJpegSettings->gps_processing_method[i] =
3001                jpeg_settings.find(ANDROID_JPEG_GPS_PROCESSING_METHOD).data.u8[i];
3002        }
3003        if (mJpegSettings->gps_processing_method[len-1] != '\0') {
3004            mJpegSettings->gps_processing_method[len] = '\0';
3005        }
3006    } else {
3007        mJpegSettings->gps_processing_method[0] = '\0';
3008    }
3009
3010    if (jpeg_settings.exists(ANDROID_SENSOR_SENSITIVITY)) {
3011        mJpegSettings->sensor_sensitivity =
3012            jpeg_settings.find(ANDROID_SENSOR_SENSITIVITY).data.i32[0];
3013    } else {
3014        mJpegSettings->sensor_sensitivity = mMetadataResponse.iso_speed;
3015    }
3016
3017    if (jpeg_settings.exists(ANDROID_LENS_FOCAL_LENGTH)) {
3018        mJpegSettings->lens_focal_length =
3019            jpeg_settings.find(ANDROID_LENS_FOCAL_LENGTH).data.f[0];
3020    }
3021    if (jpeg_settings.exists(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION)) {
3022        mJpegSettings->exposure_compensation =
3023            jpeg_settings.find(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION).data.i32[0];
3024    }
3025    mJpegSettings->exposure_comp_step = gCamCapability[mCameraId]->exp_compensation_step;
3026    mJpegSettings->max_jpeg_size = calcMaxJpegSize();
3027    return 0;
3028}
3029
3030/*===========================================================================
3031 * FUNCTION   : captureResultCb
3032 *
3033 * DESCRIPTION: Callback handler for all channels (streams, as well as metadata)
3034 *
3035 * PARAMETERS :
3036 *   @frame  : frame information from mm-camera-interface
3037 *   @buffer : actual gralloc buffer to be returned to frameworks. NULL if metadata.
3038 *   @userdata: userdata
3039 *
3040 * RETURN     : NONE
3041 *==========================================================================*/
3042void QCamera3HardwareInterface::captureResultCb(mm_camera_super_buf_t *metadata,
3043                camera3_stream_buffer_t *buffer,
3044                uint32_t frame_number, void *userdata)
3045{
3046    QCamera3HardwareInterface *hw = (QCamera3HardwareInterface *)userdata;
3047    if (hw == NULL) {
3048        ALOGE("%s: Invalid hw %p", __func__, hw);
3049        return;
3050    }
3051
3052    hw->captureResultCb(metadata, buffer, frame_number);
3053    return;
3054}
3055
3056/*===========================================================================
3057 * FUNCTION   : initialize
3058 *
3059 * DESCRIPTION: Pass framework callback pointers to HAL
3060 *
3061 * PARAMETERS :
3062 *
3063 *
3064 * RETURN     : Success : 0
3065 *              Failure: -ENODEV
3066 *==========================================================================*/
3067
3068int QCamera3HardwareInterface::initialize(const struct camera3_device *device,
3069                                  const camera3_callback_ops_t *callback_ops)
3070{
3071    ALOGV("%s: E", __func__);
3072    QCamera3HardwareInterface *hw =
3073        reinterpret_cast<QCamera3HardwareInterface *>(device->priv);
3074    if (!hw) {
3075        ALOGE("%s: NULL camera device", __func__);
3076        return -ENODEV;
3077    }
3078
3079    int rc = hw->initialize(callback_ops);
3080    ALOGV("%s: X", __func__);
3081    return rc;
3082}
3083
3084/*===========================================================================
3085 * FUNCTION   : configure_streams
3086 *
3087 * DESCRIPTION:
3088 *
3089 * PARAMETERS :
3090 *
3091 *
3092 * RETURN     : Success: 0
3093 *              Failure: -EINVAL (if stream configuration is invalid)
3094 *                       -ENODEV (fatal error)
3095 *==========================================================================*/
3096
3097int QCamera3HardwareInterface::configure_streams(
3098        const struct camera3_device *device,
3099        camera3_stream_configuration_t *stream_list)
3100{
3101    ALOGV("%s: E", __func__);
3102    QCamera3HardwareInterface *hw =
3103        reinterpret_cast<QCamera3HardwareInterface *>(device->priv);
3104    if (!hw) {
3105        ALOGE("%s: NULL camera device", __func__);
3106        return -ENODEV;
3107    }
3108    int rc = hw->configureStreams(stream_list);
3109    ALOGV("%s: X", __func__);
3110    return rc;
3111}
3112
3113/*===========================================================================
3114 * FUNCTION   : register_stream_buffers
3115 *
3116 * DESCRIPTION: Register stream buffers with the device
3117 *
3118 * PARAMETERS :
3119 *
3120 * RETURN     :
3121 *==========================================================================*/
3122int QCamera3HardwareInterface::register_stream_buffers(
3123        const struct camera3_device *device,
3124        const camera3_stream_buffer_set_t *buffer_set)
3125{
3126    ALOGV("%s: E", __func__);
3127    QCamera3HardwareInterface *hw =
3128        reinterpret_cast<QCamera3HardwareInterface *>(device->priv);
3129    if (!hw) {
3130        ALOGE("%s: NULL camera device", __func__);
3131        return -ENODEV;
3132    }
3133    int rc = hw->registerStreamBuffers(buffer_set);
3134    ALOGV("%s: X", __func__);
3135    return rc;
3136}
3137
3138/*===========================================================================
3139 * FUNCTION   : construct_default_request_settings
3140 *
3141 * DESCRIPTION: Configure a settings buffer to meet the required use case
3142 *
3143 * PARAMETERS :
3144 *
3145 *
3146 * RETURN     : Success: Return valid metadata
3147 *              Failure: Return NULL
3148 *==========================================================================*/
3149const camera_metadata_t* QCamera3HardwareInterface::
3150    construct_default_request_settings(const struct camera3_device *device,
3151                                        int type)
3152{
3153
3154    ALOGV("%s: E", __func__);
3155    camera_metadata_t* fwk_metadata = NULL;
3156    QCamera3HardwareInterface *hw =
3157        reinterpret_cast<QCamera3HardwareInterface *>(device->priv);
3158    if (!hw) {
3159        ALOGE("%s: NULL camera device", __func__);
3160        return NULL;
3161    }
3162
3163    fwk_metadata = hw->translateCapabilityToMetadata(type);
3164
3165    ALOGV("%s: X", __func__);
3166    return fwk_metadata;
3167}
3168
3169/*===========================================================================
3170 * FUNCTION   : process_capture_request
3171 *
3172 * DESCRIPTION:
3173 *
3174 * PARAMETERS :
3175 *
3176 *
3177 * RETURN     :
3178 *==========================================================================*/
3179int QCamera3HardwareInterface::process_capture_request(
3180                    const struct camera3_device *device,
3181                    camera3_capture_request_t *request)
3182{
3183    ALOGV("%s: E", __func__);
3184    QCamera3HardwareInterface *hw =
3185        reinterpret_cast<QCamera3HardwareInterface *>(device->priv);
3186    if (!hw) {
3187        ALOGE("%s: NULL camera device", __func__);
3188        return -EINVAL;
3189    }
3190
3191    int rc = hw->processCaptureRequest(request);
3192    ALOGV("%s: X", __func__);
3193    return rc;
3194}
3195
3196/*===========================================================================
3197 * FUNCTION   : get_metadata_vendor_tag_ops
3198 *
3199 * DESCRIPTION:
3200 *
3201 * PARAMETERS :
3202 *
3203 *
3204 * RETURN     :
3205 *==========================================================================*/
3206
3207void QCamera3HardwareInterface::get_metadata_vendor_tag_ops(
3208                const struct camera3_device *device,
3209                vendor_tag_query_ops_t* ops)
3210{
3211    ALOGV("%s: E", __func__);
3212    QCamera3HardwareInterface *hw =
3213        reinterpret_cast<QCamera3HardwareInterface *>(device->priv);
3214    if (!hw) {
3215        ALOGE("%s: NULL camera device", __func__);
3216        return;
3217    }
3218
3219    hw->getMetadataVendorTagOps(ops);
3220    ALOGV("%s: X", __func__);
3221    return;
3222}
3223
3224/*===========================================================================
3225 * FUNCTION   : dump
3226 *
3227 * DESCRIPTION:
3228 *
3229 * PARAMETERS :
3230 *
3231 *
3232 * RETURN     :
3233 *==========================================================================*/
3234
3235void QCamera3HardwareInterface::dump(
3236                const struct camera3_device *device, int fd)
3237{
3238    ALOGV("%s: E", __func__);
3239    QCamera3HardwareInterface *hw =
3240        reinterpret_cast<QCamera3HardwareInterface *>(device->priv);
3241    if (!hw) {
3242        ALOGE("%s: NULL camera device", __func__);
3243        return;
3244    }
3245
3246    hw->dump(fd);
3247    ALOGV("%s: X", __func__);
3248    return;
3249}
3250
3251/*===========================================================================
3252 * FUNCTION   : close_camera_device
3253 *
3254 * DESCRIPTION:
3255 *
3256 * PARAMETERS :
3257 *
3258 *
3259 * RETURN     :
3260 *==========================================================================*/
3261int QCamera3HardwareInterface::close_camera_device(struct hw_device_t* device)
3262{
3263    ALOGV("%s: E", __func__);
3264    int ret = NO_ERROR;
3265    QCamera3HardwareInterface *hw =
3266        reinterpret_cast<QCamera3HardwareInterface *>(
3267            reinterpret_cast<camera3_device_t *>(device)->priv);
3268    if (!hw) {
3269        ALOGE("NULL camera device");
3270        return BAD_VALUE;
3271    }
3272    delete hw;
3273
3274    pthread_mutex_lock(&mCameraSessionLock);
3275    mCameraSessionActive = 0;
3276    pthread_mutex_unlock(&mCameraSessionLock);
3277    ALOGV("%s: X", __func__);
3278    return ret;
3279}
3280
3281}; //end namespace qcamera
3282