CameraHal.cpp revision f8a04b91f608ec0edf05c34e6f105d08175218c5 
1/*
2 * Copyright (C) Texas Instruments - http://www.ti.com/
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17/**
18* @file CameraHal.cpp
19*
20* This file maps the Camera Hardware Interface to V4L2.
21*
22*/
23
24#define LOG_TAG "CameraHAL"
25
26#include "CameraHal.h"
27#include "ANativeWindowDisplayAdapter.h"
28#include "TICameraParameters.h"
29#include "CameraProperties.h"
30#include <cutils/properties.h>
31
32#include <poll.h>
33#include <math.h>
34
35namespace android {
36
37extern "C" CameraAdapter* CameraAdapter_Factory();
38
39/*****************************************************************************/
40
41////Constant definitions and declarations
42////@todo Have a CameraProperties class to store these parameters as constants for every camera
43////       Currently, they are hard-coded
44
45const int CameraHal::NO_BUFFERS_PREVIEW = MAX_CAMERA_BUFFERS;
46const int CameraHal::NO_BUFFERS_IMAGE_CAPTURE = 2;
47
48const uint32_t MessageNotifier::EVENT_BIT_FIELD_POSITION = 0;
49const uint32_t MessageNotifier::FRAME_BIT_FIELD_POSITION = 0;
50
51/******************************************************************************/
52
53#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
54
55struct timeval CameraHal::mStartPreview;
56struct timeval CameraHal::mStartFocus;
57struct timeval CameraHal::mStartCapture;
58
59#endif
60
61static void orientation_cb(uint32_t orientation, uint32_t tilt, void* cookie) {
62    CameraHal *camera = NULL;
63
64    if (cookie) {
65        camera = (CameraHal*) cookie;
66        camera->onOrientationEvent(orientation, tilt);
67    }
68
69}
70/*-------------Camera Hal Interface Method definitions STARTS here--------------------*/
71
72/**
73  Callback function to receive orientation events from SensorListener
74 */
75void CameraHal::onOrientationEvent(uint32_t orientation, uint32_t tilt) {
76    LOG_FUNCTION_NAME;
77
78    if ( NULL != mCameraAdapter ) {
79        mCameraAdapter->onOrientationEvent(orientation, tilt);
80    }
81
82    LOG_FUNCTION_NAME_EXIT;
83}
84
85/**
86   @brief Set the notification and data callbacks
87
88   @param[in] notify_cb Notify callback for notifying the app about events and errors
89   @param[in] data_cb   Buffer callback for sending the preview/raw frames to the app
90   @param[in] data_cb_timestamp Buffer callback for sending the video frames w/ timestamp
91   @param[in] user  Callback cookie
92   @return none
93
94 */
95void CameraHal::setCallbacks(camera_notify_callback notify_cb,
96                            camera_data_callback data_cb,
97                            camera_data_timestamp_callback data_cb_timestamp,
98                            camera_request_memory get_memory,
99                            void *user)
100{
101    LOG_FUNCTION_NAME;
102
103    if ( NULL != mAppCallbackNotifier.get() )
104    {
105            mAppCallbackNotifier->setCallbacks(this,
106                                                notify_cb,
107                                                data_cb,
108                                                data_cb_timestamp,
109                                                get_memory,
110                                                user);
111    }
112
113    LOG_FUNCTION_NAME_EXIT;
114}
115
116/**
117   @brief Enable a message, or set of messages.
118
119   @param[in] msgtype Bitmask of the messages to enable (defined in include/ui/Camera.h)
120   @return none
121
122 */
123void CameraHal::enableMsgType(int32_t msgType)
124{
125    LOG_FUNCTION_NAME;
126
127    if ( ( msgType & CAMERA_MSG_SHUTTER ) && ( !mShutterEnabled ) )
128        {
129        msgType &= ~CAMERA_MSG_SHUTTER;
130        }
131
132    {
133    Mutex::Autolock lock(mLock);
134    mMsgEnabled |= msgType;
135    }
136
137    if(mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME)
138    {
139        if(mDisplayPaused)
140        {
141            CAMHAL_LOGDA("Preview currently paused...will enable preview callback when restarted");
142            msgType &= ~CAMERA_MSG_PREVIEW_FRAME;
143        }else
144        {
145            CAMHAL_LOGDA("Enabling Preview Callback");
146        }
147    }
148    else
149    {
150        CAMHAL_LOGDB("Preview callback not enabled %x", msgType);
151    }
152
153
154    ///Configure app callback notifier with the message callback required
155    mAppCallbackNotifier->enableMsgType (msgType);
156
157    LOG_FUNCTION_NAME_EXIT;
158}
159
160/**
161   @brief Disable a message, or set of messages.
162
163   @param[in] msgtype Bitmask of the messages to disable (defined in include/ui/Camera.h)
164   @return none
165
166 */
167void CameraHal::disableMsgType(int32_t msgType)
168{
169    LOG_FUNCTION_NAME;
170
171        {
172        Mutex::Autolock lock(mLock);
173        mMsgEnabled &= ~msgType;
174        }
175
176    if( msgType & CAMERA_MSG_PREVIEW_FRAME)
177        {
178        CAMHAL_LOGDA("Disabling Preview Callback");
179        }
180
181    ///Configure app callback notifier
182    mAppCallbackNotifier->disableMsgType (msgType);
183
184    LOG_FUNCTION_NAME_EXIT;
185}
186
187/**
188   @brief Query whether a message, or a set of messages, is enabled.
189
190   Note that this is operates as an AND, if any of the messages queried are off, this will
191   return false.
192
193   @param[in] msgtype Bitmask of the messages to query (defined in include/ui/Camera.h)
194   @return true If all message types are enabled
195          false If any message type
196
197 */
198int CameraHal::msgTypeEnabled(int32_t msgType)
199{
200    LOG_FUNCTION_NAME;
201    Mutex::Autolock lock(mLock);
202    LOG_FUNCTION_NAME_EXIT;
203    return (mMsgEnabled & msgType);
204}
205
206/**
207   @brief Set the camera parameters.
208
209   @param[in] params Camera parameters to configure the camera
210   @return NO_ERROR
211   @todo Define error codes
212
213 */
214int CameraHal::setParameters(const char* parameters)
215{
216
217   LOG_FUNCTION_NAME;
218
219    CameraParameters params;
220
221    String8 str_params(parameters);
222    params.unflatten(str_params);
223
224    LOG_FUNCTION_NAME_EXIT;
225
226    return setParameters(params);
227}
228
229/**
230   @brief Set the camera parameters.
231
232   @param[in] params Camera parameters to configure the camera
233   @return NO_ERROR
234   @todo Define error codes
235
236 */
237int CameraHal::setParameters(const CameraParameters& params)
238{
239
240   LOG_FUNCTION_NAME;
241
242    int w, h;
243    int w_orig, h_orig;
244    int framerate,minframerate;
245    bool framerateUpdated = true;
246    int maxFPS, minFPS;
247    int error;
248    int base;
249    const char *valstr = NULL;
250    const char *prevFormat;
251    char *af_coord;
252    TIUTILS::Message msg;
253    status_t ret = NO_ERROR;
254    // Needed for KEY_RECORDING_HINT
255    bool restartPreviewRequired = false;
256
257    {
258        Mutex::Autolock lock(mLock);
259
260        ///Ensure that preview is not enabled when the below parameters are changed.
261        if(!previewEnabled())
262            {
263
264            CAMHAL_LOGDB("PreviewFormat %s", params.getPreviewFormat());
265
266        if ((valstr = params.getPreviewFormat()) != NULL) {
267            if ( isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FORMATS))) {
268                mParameters.setPreviewFormat(valstr);
269            } else {
270                CAMHAL_LOGEB("Invalid preview format.Supported: %s",  mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FORMATS));
271                return -EINVAL;
272            }
273        }
274
275            params.getPreviewSize(&w, &h);
276            if (w == -1 && h == -1) {
277                CAMHAL_LOGEA("Unable to get preview size");
278                return -EINVAL;
279              }
280
281            int orientation =0;
282            if((valstr = params.get(TICameraParameters::KEY_SENSOR_ORIENTATION)) != NULL)
283                {
284                CAMHAL_LOGDB("Sensor Orientation is set to %s", params.get(TICameraParameters::KEY_SENSOR_ORIENTATION));
285                mParameters.set(TICameraParameters::KEY_SENSOR_ORIENTATION, valstr);
286                orientation = params.getInt(TICameraParameters::KEY_SENSOR_ORIENTATION);
287                }
288
289            if(orientation ==90 || orientation ==270)
290           {
291              if ( !isResolutionValid(h,w, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_SIZES)))
292               {
293                CAMHAL_LOGEB("Invalid preview resolution %d x %d", w, h);
294                return -EINVAL;
295               }
296              else
297              {
298                mParameters.setPreviewSize(w, h);
299               }
300           }
301           else
302           {
303            if ( !isResolutionValid(w, h, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_SIZES)))
304                {
305                CAMHAL_LOGEB("Invalid preview resolution %d x %d", w, h);
306                return -EINVAL;
307                }
308            else
309                {
310                mParameters.setPreviewSize(w, h);
311                }
312           }
313
314            CAMHAL_LOGDB("PreviewResolution by App %d x %d", w, h);
315
316            if ((valstr = params.get(TICameraParameters::KEY_VNF)) != NULL) {
317                if ( (params.getInt(TICameraParameters::KEY_VNF)==0) || (params.getInt(TICameraParameters::KEY_VNF)==1) ) {
318                    CAMHAL_LOGDB("VNF set %s", params.get(TICameraParameters::KEY_VNF));
319                    mParameters.set(TICameraParameters::KEY_VNF, valstr);
320                } else {
321                    CAMHAL_LOGEB("ERROR: Invalid VNF: %s", valstr);
322                    ret = -EINVAL;
323                }
324            }
325
326            if ((valstr = params.get(TICameraParameters::KEY_VSTAB)) != NULL) {
327                if ((params.getInt(TICameraParameters::KEY_VSTAB)==0) || (params.getInt(TICameraParameters::KEY_VSTAB)==1)) {
328                    CAMHAL_LOGDB("VSTAB set %s", params.get(TICameraParameters::KEY_VSTAB));
329                    mParameters.set(TICameraParameters::KEY_VSTAB, valstr);
330                } else {
331                    CAMHAL_LOGEB("ERROR: Invalid VSTAB: %s", valstr);
332                    ret = -EINVAL;
333                }
334            }
335
336            if( (valstr = params.get(TICameraParameters::KEY_CAP_MODE)) != NULL)
337                {
338                CAMHAL_LOGDB("Capture mode set %s", params.get(TICameraParameters::KEY_CAP_MODE));
339                mParameters.set(TICameraParameters::KEY_CAP_MODE, valstr);
340                }
341
342            if ((valstr = params.get(TICameraParameters::KEY_IPP)) != NULL) {
343                if (isParameterValid(valstr,mCameraProperties->get(CameraProperties::SUPPORTED_IPP_MODES))) {
344                    CAMHAL_LOGDB("IPP mode set %s", params.get(TICameraParameters::KEY_IPP));
345                    mParameters.set(TICameraParameters::KEY_IPP, valstr);
346                } else {
347                    CAMHAL_LOGEB("ERROR: Invalid IPP mode: %s", valstr);
348                    ret = -EINVAL;
349                }
350            }
351
352            if((valstr = params.get(TICameraParameters::KEY_S3D2D_PREVIEW)) != NULL)
353                {
354                CAMHAL_LOGDB("Stereo 3D->2D Preview mode is %s", params.get(TICameraParameters::KEY_S3D2D_PREVIEW));
355                mParameters.set(TICameraParameters::KEY_S3D2D_PREVIEW, valstr);
356                }
357
358            if((valstr = params.get(TICameraParameters::KEY_AUTOCONVERGENCE)) != NULL)
359                {
360                CAMHAL_LOGDB("AutoConvergence mode is %s", params.get(TICameraParameters::KEY_AUTOCONVERGENCE));
361                mParameters.set(TICameraParameters::KEY_AUTOCONVERGENCE, valstr);
362                }
363
364            }
365
366        // Handle RECORDING_HINT to Set/Reset Video Mode Parameters
367        valstr = params.get(CameraParameters::KEY_RECORDING_HINT);
368        if(valstr != NULL)
369            {
370            if(strcmp(valstr, CameraParameters::TRUE) == 0)
371                {
372                CAMHAL_LOGDB("Recording Hint is set to %s", valstr);
373                mParameters.set(CameraParameters::KEY_RECORDING_HINT, valstr);
374                restartPreviewRequired = setVideoModeParameters();
375                }
376            else if(strcmp(valstr, CameraParameters::FALSE) == 0)
377                {
378                CAMHAL_LOGDB("Recording Hint is set to %s", valstr);
379                mParameters.set(CameraParameters::KEY_RECORDING_HINT, valstr);
380                restartPreviewRequired = resetVideoModeParameters();
381                }
382            else
383                {
384                CAMHAL_LOGEA("Invalid RECORDING_HINT");
385                return -EINVAL;
386                }
387            }
388        else
389            {
390            // This check is required in following case.
391            // If VideoRecording activity sets KEY_RECORDING_HINT to TRUE and
392            // ImageCapture activity doesnot set KEY_RECORDING_HINT to FALSE (i.e. simply NULL),
393            // then Video Mode parameters may remain present in ImageCapture activity as well.
394            CAMHAL_LOGDA("Recording Hint is set to NULL");
395            mParameters.set(CameraParameters::KEY_RECORDING_HINT, "");
396            restartPreviewRequired = resetVideoModeParameters();
397            }
398
399        ///Below parameters can be changed when the preview is running
400        if ( (valstr = params.getPictureFormat()) != NULL ) {
401            if (isParameterValid(params.getPictureFormat(),mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_FORMATS))) {
402                mParameters.setPictureFormat(valstr);
403            } else {
404                CAMHAL_LOGEB("ERROR: Invalid picture format: %s",valstr);
405                ret = -EINVAL;
406            }
407            }
408
409        params.getPictureSize(&w, &h);
410        if ( isResolutionValid(w, h, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_SIZES))) {
411            mParameters.setPictureSize(w, h);
412        } else {
413            CAMHAL_LOGEB("ERROR: Invalid picture resolution %dx%d", w, h);
414            ret = -EINVAL;
415        }
416
417        CAMHAL_LOGDB("Picture Size by App %d x %d", w, h);
418
419        if ((valstr = params.get(TICameraParameters::KEY_BURST)) != NULL) {
420            if (params.getInt(TICameraParameters::KEY_BURST) >=0) {
421                CAMHAL_LOGDB("Burst set %s", params.get(TICameraParameters::KEY_BURST));
422                mParameters.set(TICameraParameters::KEY_BURST, valstr);
423            } else {
424                CAMHAL_LOGEB("ERROR: Invalid Burst value: %s",valstr);
425                ret = -EINVAL;
426            }
427        }
428
429        framerate = params.getPreviewFrameRate();
430        if ( isParameterValid(framerate, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FRAME_RATES)))
431            {
432            if ( mLastPreviewFramerate != framerate )
433                {
434                mLastPreviewFramerate = framerate;
435                mParameters.setPreviewFrameRate(framerate);
436                framerateUpdated = true;
437                }
438            else
439                {
440                framerateUpdated = false;
441                }
442            }
443        else
444            {
445            framerateUpdated = false;
446            }
447
448        CAMHAL_LOGDB("FRAMERATE %d", framerate);
449
450        //If client uses fixed framerate than
451        //give it a higher piority than VFR.
452        if ( framerateUpdated )
453            {
454
455            minFPS = framerate;
456            maxFPS = framerate;
457
458            CAMHAL_LOGDB("FPS Range [%d, %d]", minFPS, maxFPS);
459            mParameters.set(TICameraParameters::KEY_MINFRAMERATE, minFPS);
460            mParameters.set(TICameraParameters::KEY_MAXFRAMERATE, maxFPS);
461            mParameters.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, params.get(CameraParameters::KEY_PREVIEW_FPS_RANGE));
462            }
463        else if ( ( valstr = params.get(CameraParameters::KEY_PREVIEW_FPS_RANGE) ) != NULL )
464            {
465            CAMHAL_LOGDB("FPS Range = %s", valstr);
466            params.getPreviewFpsRange(&minFPS, &maxFPS);
467
468            if ( ( 0 > minFPS ) || ( 0 > maxFPS ) )
469                {
470                CAMHAL_LOGEA("ERROR: FPS Range is negative!");
471                ret = -EINVAL;
472                }
473
474            minFPS /= CameraHal::VFR_SCALE;
475            maxFPS /= CameraHal::VFR_SCALE;
476
477            if ( ( 0 == minFPS ) || ( 0 == maxFPS ) )
478                {
479                CAMHAL_LOGEA("ERROR: FPS Range is invalid!");
480                ret = -EINVAL;
481                }
482
483            if ( maxFPS < minFPS )
484                {
485                CAMHAL_LOGEA("ERROR: Max FPS is smaller than Min FPS!");
486                ret = -EINVAL;
487                }
488
489            if ( maxFPS > framerate )
490                {
491                framerate = maxFPS;
492                mParameters.setPreviewFrameRate(framerate);
493                }
494
495            CAMHAL_LOGDB("FPS Range [%d, %d]", minFPS, maxFPS);
496            mParameters.set(TICameraParameters::KEY_MINFRAMERATE, minFPS);
497            mParameters.set(TICameraParameters::KEY_MAXFRAMERATE, maxFPS);
498            mParameters.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, valstr);
499            }
500
501        if( ( valstr = params.get(TICameraParameters::KEY_GBCE) ) != NULL )
502            {
503            CAMHAL_LOGDB("GBCE Value = %s", valstr);
504            mParameters.set(TICameraParameters::KEY_GBCE, valstr);
505            }
506
507        if( ( valstr = params.get(TICameraParameters::KEY_GLBCE) ) != NULL )
508            {
509            CAMHAL_LOGDB("GLBCE Value = %s", valstr);
510            mParameters.set(TICameraParameters::KEY_GLBCE, valstr);
511            }
512
513        ///Update the current parameter set
514        if( (valstr = params.get(TICameraParameters::KEY_AUTOCONVERGENCE)) != NULL)
515            {
516            CAMHAL_LOGDB("AutoConvergence Mode is set = %s", params.get(TICameraParameters::KEY_AUTOCONVERGENCE));
517            mParameters.set(TICameraParameters::KEY_AUTOCONVERGENCE, valstr);
518           }
519
520    //    if(params.get(TICameraParameters::KEY_AUTOCONVERGENCE_MODE)!=NULL)
521    //        {
522    //        CAMHAL_LOGDB("AutoConvergence Mode is set = %s", params.get(TICameraParameters::KEY_AUTOCONVERGENCE_MODE));
523    //        mParameters.set(TICameraParameters::KEY_AUTOCONVERGENCE_MODE, params.get(TICameraParameters::KEY_AUTOCONVERGENCE_MODE));
524    //        }
525
526        if( (valstr = params.get(TICameraParameters::KEY_MANUALCONVERGENCE_VALUES)) !=NULL )
527            {
528            CAMHAL_LOGDB("ManualConvergence Value = %s", params.get(TICameraParameters::KEY_MANUALCONVERGENCE_VALUES));
529            mParameters.set(TICameraParameters::KEY_MANUALCONVERGENCE_VALUES, valstr);
530            }
531
532        if ((valstr = params.get(TICameraParameters::KEY_EXPOSURE_MODE)) != NULL) {
533            if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_EXPOSURE_MODES))) {
534                CAMHAL_LOGDB("Exposure set = %s", valstr);
535                mParameters.set(TICameraParameters::KEY_EXPOSURE_MODE, valstr);
536            } else {
537                CAMHAL_LOGEB("ERROR: Invalid Exposure  = %s", valstr);
538                ret = -EINVAL;
539            }
540        }
541
542        if ((valstr = params.get(CameraParameters::KEY_WHITE_BALANCE)) != NULL) {
543           if ( isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_WHITE_BALANCE))) {
544               CAMHAL_LOGDB("White balance set %s", valstr);
545               mParameters.set(CameraParameters::KEY_WHITE_BALANCE, valstr);
546            } else {
547               CAMHAL_LOGEB("ERROR: Invalid white balance  = %s", valstr);
548               ret = -EINVAL;
549            }
550        }
551
552        if ((valstr = params.get(TICameraParameters::KEY_CONTRAST)) != NULL) {
553            if (params.getInt(TICameraParameters::KEY_CONTRAST) >= 0 ) {
554                CAMHAL_LOGDB("Contrast set %s", valstr);
555                mParameters.set(TICameraParameters::KEY_CONTRAST, valstr);
556            } else {
557                CAMHAL_LOGEB("ERROR: Invalid Contrast  = %s", valstr);
558                ret = -EINVAL;
559            }
560        }
561
562        if ((valstr =params.get(TICameraParameters::KEY_SHARPNESS)) != NULL) {
563            if (params.getInt(TICameraParameters::KEY_SHARPNESS) >= 0 ) {
564                CAMHAL_LOGDB("Sharpness set %s", valstr);
565                mParameters.set(TICameraParameters::KEY_SHARPNESS, valstr);
566            } else {
567                CAMHAL_LOGEB("ERROR: Invalid Sharpness = %s", valstr);
568                ret = -EINVAL;
569            }
570        }
571
572        if ((valstr = params.get(TICameraParameters::KEY_SATURATION)) != NULL) {
573            if (params.getInt(TICameraParameters::KEY_SATURATION) >= 0 ) {
574                CAMHAL_LOGDB("Saturation set %s", valstr);
575                mParameters.set(TICameraParameters::KEY_SATURATION, valstr);
576             } else {
577                CAMHAL_LOGEB("ERROR: Invalid Saturation = %s", valstr);
578                ret = -EINVAL;
579            }
580        }
581
582        if ((valstr = params.get(TICameraParameters::KEY_BRIGHTNESS)) != NULL) {
583            if (params.getInt(TICameraParameters::KEY_BRIGHTNESS) >= 0 ) {
584                CAMHAL_LOGDB("Brightness set %s", valstr);
585                mParameters.set(TICameraParameters::KEY_BRIGHTNESS, valstr);
586            } else {
587                CAMHAL_LOGEB("ERROR: Invalid Brightness = %s", valstr);
588                ret = -EINVAL;
589            }
590         }
591
592        if ((valstr = params.get(CameraParameters::KEY_ANTIBANDING)) != NULL) {
593            if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_ANTIBANDING))) {
594                CAMHAL_LOGDB("Antibanding set %s", valstr);
595                mParameters.set(CameraParameters::KEY_ANTIBANDING, valstr);
596             } else {
597                CAMHAL_LOGEB("ERROR: Invalid Antibanding = %s", valstr);
598                ret = -EINVAL;
599             }
600         }
601
602        if ((valstr = params.get(TICameraParameters::KEY_ISO)) != NULL) {
603            if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_ISO_VALUES))) {
604                CAMHAL_LOGDB("ISO set %s", valstr);
605                mParameters.set(TICameraParameters::KEY_ISO, valstr);
606            } else {
607                CAMHAL_LOGEB("ERROR: Invalid ISO = %s", valstr);
608                ret = -EINVAL;
609            }
610        }
611
612        if ((valstr = params.get(CameraParameters::KEY_FOCUS_MODE)) != NULL) {
613            if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_FOCUS_MODES))) {
614                CAMHAL_LOGDB("Focus mode set %s", params.get(CameraParameters::KEY_FOCUS_MODE));
615                mParameters.set(CameraParameters::KEY_FOCUS_MODE, valstr);
616             } else {
617                CAMHAL_LOGEB("ERROR: Invalid FOCUS mode = %s", valstr);
618                ret = -EINVAL;
619             }
620        }
621
622        if( (valstr = params.get(CameraParameters::KEY_FOCUS_AREAS)) != NULL )
623            {
624            CAMHAL_LOGEB("Focus areas position set %s", params.get(CameraParameters::KEY_FOCUS_AREAS));
625            mParameters.set(CameraParameters::KEY_FOCUS_AREAS, valstr);
626            }
627
628        if( (valstr = params.get(TICameraParameters::KEY_MEASUREMENT_ENABLE)) != NULL )
629            {
630            CAMHAL_LOGDB("Measurements set to %s", params.get(TICameraParameters::KEY_MEASUREMENT_ENABLE));
631            mParameters.set(TICameraParameters::KEY_MEASUREMENT_ENABLE, valstr);
632
633            if (strcmp(valstr, (const char *) TICameraParameters::MEASUREMENT_ENABLE) == 0)
634                {
635                mMeasurementEnabled = true;
636                }
637            else if (strcmp(valstr, (const char *) TICameraParameters::MEASUREMENT_DISABLE) == 0)
638                {
639                mMeasurementEnabled = false;
640                }
641            else
642                {
643                mMeasurementEnabled = false;
644                }
645
646            }
647
648        if( (valstr = params.get(CameraParameters::KEY_EXPOSURE_COMPENSATION)) != NULL)
649            {
650            CAMHAL_LOGDB("Exposure compensation set %s", params.get(CameraParameters::KEY_EXPOSURE_COMPENSATION));
651            mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, valstr);
652            }
653
654        if ((valstr = params.get(CameraParameters::KEY_SCENE_MODE)) != NULL) {
655            if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_SCENE_MODES))) {
656                CAMHAL_LOGDB("Scene mode set %s", valstr);
657                mParameters.set(CameraParameters::KEY_SCENE_MODE, valstr);
658            } else {
659                CAMHAL_LOGEB("ERROR: Invalid Scene mode = %s", valstr);
660                ret = -EINVAL;
661            }
662        }
663
664        if ((valstr = params.get(CameraParameters::KEY_FLASH_MODE)) != NULL) {
665            if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_FLASH_MODES))) {
666                CAMHAL_LOGDB("Flash mode set %s", valstr);
667                mParameters.set(CameraParameters::KEY_FLASH_MODE, valstr);
668            } else {
669                CAMHAL_LOGEB("ERROR: Invalid Flash mode = %s", valstr);
670                ret = -EINVAL;
671            }
672        }
673
674        if ((valstr = params.get(CameraParameters::KEY_EFFECT)) != NULL) {
675            if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_EFFECTS))) {
676                CAMHAL_LOGDB("Effect set %s", valstr);
677                mParameters.set(CameraParameters::KEY_EFFECT, valstr);
678             } else {
679                CAMHAL_LOGEB("ERROR: Invalid Effect = %s", valstr);
680                ret = -EINVAL;
681             }
682        }
683
684        if(( (valstr = params.get(CameraParameters::KEY_ROTATION)) != NULL)
685            && (params.getInt(CameraParameters::KEY_ROTATION) >=0))
686            {
687            CAMHAL_LOGDB("Rotation set %s", params.get(CameraParameters::KEY_ROTATION));
688            mParameters.set(CameraParameters::KEY_ROTATION, valstr);
689            }
690
691        if(( (valstr = params.get(CameraParameters::KEY_JPEG_QUALITY)) != NULL)
692            && (params.getInt(CameraParameters::KEY_JPEG_QUALITY) >=0))
693            {
694            CAMHAL_LOGDB("Jpeg quality set %s", params.get(CameraParameters::KEY_JPEG_QUALITY));
695            mParameters.set(CameraParameters::KEY_JPEG_QUALITY, valstr);
696            }
697
698        if(( (valstr = params.get(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH)) != NULL)
699            && (params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH) >=0))
700            {
701            CAMHAL_LOGDB("Thumbnail width set %s", params.get(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH));
702            mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, valstr);
703            }
704
705        if(( (valstr = params.get(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT)) != NULL)
706            && (params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT) >=0))
707            {
708            CAMHAL_LOGDB("Thumbnail width set %s", params.get(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT));
709            mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, valstr);
710            }
711
712        if(( (valstr = params.get(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY)) != NULL )
713            && (params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY) >=0))
714            {
715            CAMHAL_LOGDB("Thumbnail quality set %s", params.get(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY));
716            mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, valstr);
717            }
718
719        if( (valstr = params.get(CameraParameters::KEY_GPS_LATITUDE)) != NULL )
720            {
721            CAMHAL_LOGDB("GPS latitude set %s", params.get(CameraParameters::KEY_GPS_LATITUDE));
722            mParameters.set(CameraParameters::KEY_GPS_LATITUDE, valstr);
723            }else{
724                mParameters.remove(CameraParameters::KEY_GPS_LATITUDE);
725            }
726
727        if( (valstr = params.get(CameraParameters::KEY_GPS_LONGITUDE)) != NULL )
728            {
729            CAMHAL_LOGDB("GPS longitude set %s", params.get(CameraParameters::KEY_GPS_LONGITUDE));
730            mParameters.set(CameraParameters::KEY_GPS_LONGITUDE, valstr);
731            }else{
732                mParameters.remove(CameraParameters::KEY_GPS_LONGITUDE);
733            }
734
735        if( (valstr = params.get(CameraParameters::KEY_GPS_ALTITUDE)) != NULL )
736            {
737            CAMHAL_LOGDB("GPS altitude set %s", params.get(CameraParameters::KEY_GPS_ALTITUDE));
738            mParameters.set(CameraParameters::KEY_GPS_ALTITUDE, valstr);
739            }else{
740                mParameters.remove(CameraParameters::KEY_GPS_ALTITUDE);
741            }
742
743        if( (valstr = params.get(CameraParameters::KEY_GPS_TIMESTAMP)) != NULL )
744            {
745            CAMHAL_LOGDB("GPS timestamp set %s", params.get(CameraParameters::KEY_GPS_TIMESTAMP));
746            mParameters.set(CameraParameters::KEY_GPS_TIMESTAMP, valstr);
747            }else{
748                mParameters.remove(CameraParameters::KEY_GPS_TIMESTAMP);
749            }
750
751        if( (valstr = params.get(TICameraParameters::KEY_GPS_DATESTAMP)) != NULL )
752            {
753            CAMHAL_LOGDB("GPS datestamp set %s", params.get(TICameraParameters::KEY_GPS_DATESTAMP));
754            mParameters.set(TICameraParameters::KEY_GPS_DATESTAMP, valstr);
755            }else{
756                mParameters.remove(TICameraParameters::KEY_GPS_DATESTAMP);
757            }
758
759        if( (valstr = params.get(CameraParameters::KEY_GPS_PROCESSING_METHOD)) != NULL )
760            {
761            CAMHAL_LOGDB("GPS processing method set %s", params.get(CameraParameters::KEY_GPS_PROCESSING_METHOD));
762            mParameters.set(CameraParameters::KEY_GPS_PROCESSING_METHOD, valstr);
763            }else{
764                mParameters.remove(CameraParameters::KEY_GPS_PROCESSING_METHOD);
765            }
766
767        if( (valstr = params.get(TICameraParameters::KEY_GPS_MAPDATUM )) != NULL )
768            {
769            CAMHAL_LOGDB("GPS MAPDATUM set %s", params.get(TICameraParameters::KEY_GPS_MAPDATUM));
770            mParameters.set(TICameraParameters::KEY_GPS_MAPDATUM, valstr);
771            }else{
772                mParameters.remove(TICameraParameters::KEY_GPS_MAPDATUM);
773            }
774
775        if( (valstr = params.get(TICameraParameters::KEY_GPS_VERSION)) != NULL )
776            {
777            CAMHAL_LOGDB("GPS MAPDATUM set %s", params.get(TICameraParameters::KEY_GPS_VERSION));
778            mParameters.set(TICameraParameters::KEY_GPS_VERSION, valstr);
779            }else{
780                mParameters.remove(TICameraParameters::KEY_GPS_VERSION);
781            }
782
783        if( (valstr = params.get(TICameraParameters::KEY_EXIF_MODEL)) != NULL )
784            {
785            CAMHAL_LOGDB("EXIF Model set %s", params.get(TICameraParameters::KEY_EXIF_MODEL));
786            mParameters.set(TICameraParameters::KEY_EXIF_MODEL, valstr);
787            }
788
789        if( (valstr = params.get(TICameraParameters::KEY_EXIF_MAKE)) != NULL )
790            {
791            CAMHAL_LOGDB("EXIF Make set %s", params.get(TICameraParameters::KEY_EXIF_MAKE));
792            mParameters.set(TICameraParameters::KEY_EXIF_MAKE, valstr);
793            }
794
795        if( (valstr = params.get(TICameraParameters::KEY_EXP_BRACKETING_RANGE)) != NULL )
796            {
797            CAMHAL_LOGDB("Exposure Bracketing set %s", params.get(TICameraParameters::KEY_EXP_BRACKETING_RANGE));
798            mParameters.set(TICameraParameters::KEY_EXP_BRACKETING_RANGE, valstr);
799            }
800        else
801            {
802            mParameters.remove(TICameraParameters::KEY_EXP_BRACKETING_RANGE);
803            }
804
805        if ((valstr = params.get(CameraParameters::KEY_ZOOM)) != NULL ) {
806            if ((params.getInt(CameraParameters::KEY_ZOOM) >= 0 ) &&
807                (params.getInt(CameraParameters::KEY_ZOOM) <= mMaxZoomSupported )) {
808                CAMHAL_LOGDB("Zoom set %s", valstr);
809                mParameters.set(CameraParameters::KEY_ZOOM, valstr);
810             } else {
811                CAMHAL_LOGEB("ERROR: Invalid Zoom: %s", valstr);
812                ret = -EINVAL;
813            }
814        }
815
816        if( (valstr = params.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK)) != NULL )
817          {
818            CAMHAL_LOGDB("Auto Exposure Lock set %s", params.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK));
819            mParameters.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, valstr);
820          }
821
822        if( (valstr = params.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK)) != NULL )
823          {
824            CAMHAL_LOGDB("Auto WhiteBalance Lock set %s", params.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK));
825            mParameters.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, valstr);
826          }
827
828        CameraParameters adapterParams = mParameters;
829
830        //If the app has not set the capture mode, set the capture resolution as preview resolution
831        //so that black bars are not displayed in preview.
832        //Later in takePicture we will configure the correct picture size
833        if(mParameters.get(TICameraParameters::KEY_CAP_MODE) == NULL)
834            {
835            CAMHAL_LOGDA("Capture mode not set by app, setting picture res to preview res");
836            mParameters.getPreviewSize(&w, &h);
837            adapterParams.setPictureSize(w,h);
838            }
839
840        // Only send parameters to adapter if preview is already
841        // enabled. Initial setParameters to camera adapter, will
842        // be called in startPreview()
843        if ( NULL != mCameraAdapter && mPreviewEnabled ) {
844            ret |= mCameraAdapter->setParameters(adapterParams);
845        }
846
847        if( NULL != params.get(TICameraParameters::KEY_TEMP_BRACKETING_RANGE_POS) )
848            {
849            int posBracketRange = params.getInt(TICameraParameters::KEY_TEMP_BRACKETING_RANGE_POS);
850            if ( 0 < posBracketRange )
851                {
852                mBracketRangePositive = posBracketRange;
853                }
854            }
855        CAMHAL_LOGDB("Positive bracketing range %d", mBracketRangePositive);
856
857
858        if( NULL != params.get(TICameraParameters::KEY_TEMP_BRACKETING_RANGE_NEG) )
859            {
860            int negBracketRange = params.getInt(TICameraParameters::KEY_TEMP_BRACKETING_RANGE_NEG);
861            if ( 0 < negBracketRange )
862                {
863                mBracketRangeNegative = negBracketRange;
864                }
865            }
866        CAMHAL_LOGDB("Negative bracketing range %d", mBracketRangeNegative);
867
868        if( ( (valstr = params.get(TICameraParameters::KEY_TEMP_BRACKETING)) != NULL) &&
869            ( strcmp(valstr, TICameraParameters::BRACKET_ENABLE) == 0 ))
870            {
871            if ( !mBracketingEnabled )
872                {
873                CAMHAL_LOGDA("Enabling bracketing");
874                mBracketingEnabled = true;
875
876                //Wait for AF events to enable bracketing
877                if ( NULL != mCameraAdapter )
878                    {
879                    setEventProvider( CameraHalEvent::ALL_EVENTS, mCameraAdapter );
880                    }
881                }
882            else
883                {
884                CAMHAL_LOGDA("Bracketing already enabled");
885                }
886            }
887        else if ( ( (valstr = params.get(TICameraParameters::KEY_TEMP_BRACKETING)) != NULL ) &&
888            ( strcmp(valstr, TICameraParameters::BRACKET_DISABLE) == 0 ))
889            {
890            CAMHAL_LOGDA("Disabling bracketing");
891
892            mBracketingEnabled = false;
893            stopImageBracketing();
894
895            //Remove AF events subscription
896            if ( NULL != mEventProvider )
897                {
898                mEventProvider->disableEventNotification( CameraHalEvent::ALL_EVENTS );
899                delete mEventProvider;
900                mEventProvider = NULL;
901                }
902
903            }
904
905        if( ( (valstr = params.get(TICameraParameters::KEY_SHUTTER_ENABLE)) != NULL ) &&
906            ( strcmp(valstr, TICameraParameters::SHUTTER_ENABLE) == 0 ))
907            {
908            CAMHAL_LOGDA("Enabling shutter sound");
909
910            mShutterEnabled = true;
911            mMsgEnabled |= CAMERA_MSG_SHUTTER;
912            mParameters.set(TICameraParameters::KEY_SHUTTER_ENABLE, valstr);
913            }
914        else if ( ( (valstr = params.get(TICameraParameters::KEY_SHUTTER_ENABLE)) != NULL ) &&
915            ( strcmp(valstr, TICameraParameters::SHUTTER_DISABLE) == 0 ))
916            {
917            CAMHAL_LOGDA("Disabling shutter sound");
918
919            mShutterEnabled = false;
920            mMsgEnabled &= ~CAMERA_MSG_SHUTTER;
921            mParameters.set(TICameraParameters::KEY_SHUTTER_ENABLE, valstr);
922            }
923
924    }
925
926    // Restart Preview if needed by KEY_RECODING_HINT only if preview is already running.
927    // If preview is not started yet, Video Mode parameters will take effect on next startPreview()
928    if(restartPreviewRequired && previewEnabled())
929        {
930        CAMHAL_LOGDA("Restarting Preview as needed by KEY_RECODING_HINT");
931        ret = restartPreview();
932        }
933    if (ret != NO_ERROR)
934        {
935        CAMHAL_LOGEA("Failed to restart Preview");
936        return ret;
937        }
938
939    LOG_FUNCTION_NAME_EXIT;
940
941    return ret;
942}
943
944status_t CameraHal::allocPreviewBufs(int width, int height, const char* previewFormat,
945                                        unsigned int buffercount, unsigned int &max_queueable)
946{
947    status_t ret = NO_ERROR;
948
949    LOG_FUNCTION_NAME;
950
951    if(mDisplayAdapter.get() == NULL)
952    {
953        // Memory allocation of preview buffers is now placed in gralloc
954        // CameraHal should not allocate preview buffers without DisplayAdapter
955        return NO_MEMORY;
956    }
957
958    if(!mPreviewBufs)
959    {
960        ///@todo Pluralise the name of this method to allocateBuffers
961        mPreviewLength = 0;
962        mPreviewBufs = (int32_t *) mDisplayAdapter->allocateBuffer(width, height,
963                                                                    previewFormat,
964                                                                    mPreviewLength,
965                                                                    buffercount);
966
967	if (NULL == mPreviewBufs ) {
968            CAMHAL_LOGEA("Couldn't allocate preview buffers");
969            return NO_MEMORY;
970         }
971
972        mPreviewOffsets = (uint32_t *) mDisplayAdapter->getOffsets();
973        if ( NULL == mPreviewOffsets ) {
974            CAMHAL_LOGEA("Buffer mapping failed");
975            return BAD_VALUE;
976         }
977
978        mPreviewFd = mDisplayAdapter->getFd();
979        if ( -1 == mPreviewFd ) {
980            CAMHAL_LOGEA("Invalid handle");
981            return BAD_VALUE;
982          }
983
984        mBufProvider = (BufferProvider*) mDisplayAdapter.get();
985
986        ret = mDisplayAdapter->maxQueueableBuffers(max_queueable);
987        if (ret != NO_ERROR) {
988            return ret;
989         }
990
991    }
992
993    LOG_FUNCTION_NAME_EXIT;
994
995    return ret;
996
997}
998
999status_t CameraHal::freePreviewBufs()
1000{
1001    status_t ret = NO_ERROR;
1002    LOG_FUNCTION_NAME;
1003
1004    CAMHAL_LOGDB("mPreviewBufs = 0x%x", (unsigned int)mPreviewBufs);
1005    if(mPreviewBufs)
1006        {
1007        ///@todo Pluralise the name of this method to freeBuffers
1008        ret = mBufProvider->freeBuffer(mPreviewBufs);
1009        mPreviewBufs = NULL;
1010        LOG_FUNCTION_NAME_EXIT;
1011        return ret;
1012        }
1013    LOG_FUNCTION_NAME_EXIT;
1014    return ret;
1015}
1016
1017
1018status_t CameraHal::allocPreviewDataBufs(size_t size, size_t bufferCount)
1019{
1020    status_t ret = NO_ERROR;
1021    int bytes;
1022
1023    LOG_FUNCTION_NAME;
1024
1025    bytes = size;
1026
1027    if ( NO_ERROR == ret )
1028        {
1029        if( NULL != mPreviewDataBufs )
1030            {
1031            ret = freePreviewDataBufs();
1032            }
1033        }
1034
1035    if ( NO_ERROR == ret )
1036        {
1037        mPreviewDataBufs = (int32_t *)mMemoryManager->allocateBuffer(0, 0, NULL, bytes, bufferCount);
1038
1039        CAMHAL_LOGDB("Size of Preview data buffer = %d", bytes);
1040        if( NULL == mPreviewDataBufs )
1041            {
1042            CAMHAL_LOGEA("Couldn't allocate image buffers using memory manager");
1043            ret = -NO_MEMORY;
1044            }
1045        else
1046            {
1047            bytes = size;
1048            }
1049        }
1050
1051    if ( NO_ERROR == ret )
1052        {
1053        mPreviewDataFd = mMemoryManager->getFd();
1054        mPreviewDataLength = bytes;
1055        mPreviewDataOffsets = mMemoryManager->getOffsets();
1056        }
1057    else
1058        {
1059        mPreviewDataFd = -1;
1060        mPreviewDataLength = 0;
1061        mPreviewDataOffsets = NULL;
1062        }
1063
1064    LOG_FUNCTION_NAME;
1065
1066    return ret;
1067}
1068
1069status_t CameraHal::freePreviewDataBufs()
1070{
1071    status_t ret = NO_ERROR;
1072
1073    LOG_FUNCTION_NAME;
1074
1075    if ( NO_ERROR == ret )
1076        {
1077
1078        if( NULL != mPreviewDataBufs )
1079            {
1080
1081            ///@todo Pluralise the name of this method to freeBuffers
1082            ret = mMemoryManager->freeBuffer(mPreviewDataBufs);
1083            mPreviewDataBufs = NULL;
1084
1085            }
1086        else
1087            {
1088            CAMHAL_LOGEA("Couldn't free PreviewDataBufs allocated by memory manager");
1089            ret = -EINVAL;
1090            }
1091
1092        }
1093
1094    LOG_FUNCTION_NAME_EXIT;
1095
1096    return ret;
1097}
1098
1099status_t CameraHal::allocImageBufs(unsigned int width, unsigned int height, size_t size, const char* previewFormat, unsigned int bufferCount)
1100{
1101    status_t ret = NO_ERROR;
1102    int bytes;
1103
1104    LOG_FUNCTION_NAME;
1105
1106    bytes = size;
1107
1108    ///Always allocate the buffers for image capture using MemoryManager
1109    if ( NO_ERROR == ret )
1110        {
1111        if( ( NULL != mImageBufs ) )
1112            {
1113            ret = freeImageBufs();
1114            }
1115        }
1116
1117    if ( NO_ERROR == ret )
1118        {
1119        mImageBufs = (int32_t *)mMemoryManager->allocateBuffer(0, 0, previewFormat, bytes, bufferCount);
1120
1121        CAMHAL_LOGDB("Size of Image cap buffer = %d", bytes);
1122        if( NULL == mImageBufs )
1123            {
1124            CAMHAL_LOGEA("Couldn't allocate image buffers using memory manager");
1125            ret = -NO_MEMORY;
1126            }
1127        else
1128            {
1129            bytes = size;
1130            }
1131        }
1132
1133    if ( NO_ERROR == ret )
1134        {
1135        mImageFd = mMemoryManager->getFd();
1136        mImageLength = bytes;
1137        mImageOffsets = mMemoryManager->getOffsets();
1138        }
1139    else
1140        {
1141        mImageFd = -1;
1142        mImageLength = 0;
1143        mImageOffsets = NULL;
1144        }
1145
1146    LOG_FUNCTION_NAME;
1147
1148    return ret;
1149}
1150
1151void endImageCapture( void *userData)
1152{
1153    LOG_FUNCTION_NAME;
1154
1155    if ( NULL != userData )
1156        {
1157        CameraHal *c = reinterpret_cast<CameraHal *>(userData);
1158        c->signalEndImageCapture();
1159        }
1160
1161    LOG_FUNCTION_NAME_EXIT;
1162}
1163
1164void releaseImageBuffers(void *userData)
1165{
1166    LOG_FUNCTION_NAME;
1167
1168    if ( NULL != userData )
1169        {
1170        CameraHal *c = reinterpret_cast<CameraHal *>(userData);
1171        c->freeImageBufs();
1172        }
1173
1174    LOG_FUNCTION_NAME_EXIT;
1175}
1176
1177status_t CameraHal::signalEndImageCapture()
1178{
1179    status_t ret = NO_ERROR;
1180    int w,h;
1181    CameraParameters adapterParams = mParameters;
1182    Mutex::Autolock lock(mLock);
1183
1184    LOG_FUNCTION_NAME;
1185
1186    mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_IMAGE_CAPTURE);
1187
1188    //If the app has not set the capture mode, restore the capture resolution
1189    //back to the preview resolution to get rid of the black bars issue
1190    if (mParameters.get(TICameraParameters::KEY_CAP_MODE) == NULL) {
1191        CAMHAL_LOGDA("Capture mode not set by app, setting picture res back to preview res");
1192        mParameters.getPreviewSize(&w, &h);
1193        adapterParams.setPictureSize(w,h);
1194        ret = mCameraAdapter->setParameters(adapterParams);
1195    }
1196
1197    LOG_FUNCTION_NAME_EXIT;
1198
1199    return ret;
1200}
1201
1202status_t CameraHal::freeImageBufs()
1203{
1204    status_t ret = NO_ERROR;
1205
1206    LOG_FUNCTION_NAME;
1207
1208    if ( NO_ERROR == ret )
1209        {
1210
1211        if( NULL != mImageBufs )
1212            {
1213
1214            ///@todo Pluralise the name of this method to freeBuffers
1215            ret = mMemoryManager->freeBuffer(mImageBufs);
1216            mImageBufs = NULL;
1217
1218            }
1219        else
1220            {
1221            ret = -EINVAL;
1222            }
1223
1224        }
1225
1226    LOG_FUNCTION_NAME_EXIT;
1227
1228    return ret;
1229}
1230
1231
1232
1233/**
1234   @brief Start preview mode.
1235
1236   @param none
1237   @return NO_ERROR Camera switched to VF mode
1238   @todo Update function header with the different errors that are possible
1239
1240 */
1241status_t CameraHal::startPreview()
1242{
1243
1244    status_t ret = NO_ERROR;
1245    CameraAdapter::BuffersDescriptor desc;
1246    CameraFrame frame;
1247    const char *valstr = NULL;
1248    unsigned int required_buffer_count;
1249    unsigned int max_queueble_buffers;
1250
1251#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
1252
1253        gettimeofday(&mStartPreview, NULL);
1254
1255#endif
1256
1257    LOG_FUNCTION_NAME;
1258
1259    if( (mDisplayAdapter.get() != NULL) && ( !mPreviewEnabled ) && ( mDisplayPaused ) )
1260        {
1261        CAMHAL_LOGDA("Preview is in paused state");
1262
1263        mDisplayPaused = false;
1264        mPreviewEnabled = true;
1265        if ( NO_ERROR == ret )
1266            {
1267            ret = mDisplayAdapter->pauseDisplay(mDisplayPaused);
1268
1269            if ( NO_ERROR != ret )
1270                {
1271                CAMHAL_LOGEB("Display adapter resume failed %x", ret);
1272                }
1273            }
1274        //restart preview callbacks
1275        if(mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME)
1276        {
1277            mAppCallbackNotifier->enableMsgType (CAMERA_MSG_PREVIEW_FRAME);
1278        }
1279        return ret;
1280
1281        }
1282    else if ( mPreviewEnabled )
1283        {
1284        CAMHAL_LOGDA("Preview already running");
1285
1286        LOG_FUNCTION_NAME_EXIT;
1287
1288        return ALREADY_EXISTS;
1289        }
1290
1291    ///If we don't have the preview callback enabled and display adapter,
1292    if(!mSetPreviewWindowCalled || (mDisplayAdapter.get() == NULL))
1293    {
1294        CAMHAL_LOGEA("Preview not started. Preview in progress flag set");
1295        mPreviewStartInProgress = true;
1296        return NO_ERROR;
1297    }
1298
1299    if ( NULL != mCameraAdapter ) {
1300
1301        CameraParameters adapterParams = mParameters;
1302
1303        //If the app has not set the capture mode, set the capture resolution as preview resolution
1304        //so that black bars are not displayed in preview.
1305        //Later in takePicture we will configure the correct picture size
1306        if(mParameters.get(TICameraParameters::KEY_CAP_MODE) == NULL)
1307            {
1308            int w,h;
1309            CAMHAL_LOGDA("Capture mode not set by app, setting picture res to preview res");
1310            mParameters.getPreviewSize(&w, &h);
1311            adapterParams.setPictureSize(w,h);
1312            }
1313
1314        ret = mCameraAdapter->setParameters(adapterParams);
1315    }
1316
1317    /// Ensure that buffers for preview are allocated before we start the camera
1318    ///Get the updated size from Camera Adapter, to account for padding etc
1319    ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_RESOLUTION_PREVIEW,
1320                                      ( int ) &frame);
1321    if ( NO_ERROR != ret )
1322        {
1323        return ret;
1324        }
1325
1326    ///Update the current preview width and height
1327    mPreviewWidth = frame.mWidth;
1328    mPreviewHeight = frame.mHeight;
1329
1330    //Update the padded width and height - required for VNF and VSTAB
1331    mParameters.set(TICameraParameters::KEY_PADDED_WIDTH, mPreviewWidth);
1332    mParameters.set(TICameraParameters::KEY_PADDED_HEIGHT, mPreviewHeight);
1333
1334    required_buffer_count = atoi(mCameraProperties->get(CameraProperties::REQUIRED_PREVIEW_BUFS));
1335
1336    ///Allocate the preview buffers
1337    ret = allocPreviewBufs(frame.mWidth, frame.mHeight, mParameters.getPreviewFormat(), required_buffer_count, max_queueble_buffers);
1338
1339    if ( NO_ERROR != ret )
1340        {
1341        CAMHAL_LOGEA("Couldn't allocate buffers for Preview");
1342        goto error;
1343        }
1344
1345    if ( mMeasurementEnabled )
1346        {
1347
1348        ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_PREVIEW_DATA,
1349                                          ( int ) &frame,
1350                                          required_buffer_count);
1351        if ( NO_ERROR != ret )
1352            {
1353            return ret;
1354            }
1355
1356         ///Allocate the preview data buffers
1357        ret = allocPreviewDataBufs(frame.mLength, required_buffer_count);
1358        if ( NO_ERROR != ret ) {
1359            CAMHAL_LOGEA("Couldn't allocate preview data buffers");
1360            goto error;
1361           }
1362
1363        if ( NO_ERROR == ret )
1364            {
1365            desc.mBuffers = mPreviewDataBufs;
1366            desc.mOffsets = mPreviewDataOffsets;
1367            desc.mFd = mPreviewDataFd;
1368            desc.mLength = mPreviewDataLength;
1369            desc.mCount = ( size_t ) required_buffer_count;
1370            desc.mMaxQueueable = (size_t) required_buffer_count;
1371
1372            mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_PREVIEW_DATA,
1373                                        ( int ) &desc);
1374            }
1375
1376        }
1377
1378    ///Pass the buffers to Camera Adapter
1379    desc.mBuffers = mPreviewBufs;
1380    desc.mOffsets = mPreviewOffsets;
1381    desc.mFd = mPreviewFd;
1382    desc.mLength = mPreviewLength;
1383    desc.mCount = ( size_t ) required_buffer_count;
1384    desc.mMaxQueueable = (size_t) max_queueble_buffers;
1385
1386    mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_PREVIEW,
1387                                ( int ) &desc);
1388
1389    mAppCallbackNotifier->startPreviewCallbacks(mParameters, mPreviewBufs, mPreviewOffsets, mPreviewFd, mPreviewLength, required_buffer_count);
1390
1391    ///Start the callback notifier
1392    ret = mAppCallbackNotifier->start();
1393
1394    if( ALREADY_EXISTS == ret )
1395        {
1396        //Already running, do nothing
1397        CAMHAL_LOGDA("AppCallbackNotifier already running");
1398        ret = NO_ERROR;
1399        }
1400    else if ( NO_ERROR == ret ) {
1401        CAMHAL_LOGDA("Started AppCallbackNotifier..");
1402        mAppCallbackNotifier->setMeasurements(mMeasurementEnabled);
1403        }
1404    else
1405        {
1406        CAMHAL_LOGDA("Couldn't start AppCallbackNotifier");
1407        goto error;
1408        }
1409
1410    ///Enable the display adapter if present, actual overlay enable happens when we post the buffer
1411    if(mDisplayAdapter.get() != NULL)
1412        {
1413        CAMHAL_LOGDA("Enabling display");
1414        bool isS3d = false;
1415        DisplayAdapter::S3DParameters s3dParams;
1416        int width, height;
1417        mParameters.getPreviewSize(&width, &height);
1418#if 0 //TODO: s3d is not part of bringup...will reenable
1419        if ( (valstr = mParameters.get(TICameraParameters::KEY_S3D_SUPPORTED)) != NULL) {
1420            isS3d = (strcmp(valstr, "true") == 0);
1421        }
1422        if ( (valstr = mParameters.get(TICameraParameters::KEY_S3D2D_PREVIEW)) != NULL) {
1423            if (strcmp(valstr, "off") == 0)
1424                {
1425                CAMHAL_LOGEA("STEREO 3D->2D PREVIEW MODE IS OFF");
1426                //TODO: obtain the frame packing configuration from camera or user settings
1427                //once side by side configuration is supported
1428                s3dParams.mode = OVERLAY_S3D_MODE_ON;
1429                s3dParams.framePacking = OVERLAY_S3D_FORMAT_OVERUNDER;
1430                s3dParams.order = OVERLAY_S3D_ORDER_LF;
1431                s3dParams.subSampling = OVERLAY_S3D_SS_NONE;
1432                }
1433            else
1434                {
1435                CAMHAL_LOGEA("STEREO 3D->2D PREVIEW MODE IS ON");
1436                s3dParams.mode = OVERLAY_S3D_MODE_OFF;
1437                s3dParams.framePacking = OVERLAY_S3D_FORMAT_OVERUNDER;
1438                s3dParams.order = OVERLAY_S3D_ORDER_LF;
1439                s3dParams.subSampling = OVERLAY_S3D_SS_NONE;
1440                }
1441        }
1442#endif //if 0
1443
1444#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
1445
1446        ret = mDisplayAdapter->enableDisplay(width, height, &mStartPreview, isS3d ? &s3dParams : NULL);
1447
1448#else
1449
1450        ret = mDisplayAdapter->enableDisplay(width, height, NULL, isS3d ? &s3dParams : NULL);
1451
1452#endif
1453
1454        if ( ret != NO_ERROR )
1455            {
1456            CAMHAL_LOGEA("Couldn't enable display");
1457            goto error;
1458            }
1459
1460        }
1461
1462    ///Send START_PREVIEW command to adapter
1463    CAMHAL_LOGDA("Starting CameraAdapter preview mode");
1464
1465    ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_PREVIEW);
1466
1467    if(ret!=NO_ERROR)
1468        {
1469        CAMHAL_LOGEA("Couldn't start preview w/ CameraAdapter");
1470        goto error;
1471        }
1472    CAMHAL_LOGDA("Started preview");
1473
1474    mPreviewEnabled = true;
1475    mPreviewStartInProgress = false;
1476    return ret;
1477
1478    error:
1479
1480        CAMHAL_LOGEA("Performing cleanup after error");
1481
1482        //Do all the cleanup
1483        freePreviewBufs();
1484        mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_PREVIEW);
1485        if(mDisplayAdapter.get() != NULL)
1486            {
1487            mDisplayAdapter->disableDisplay();
1488            }
1489        mAppCallbackNotifier->stop();
1490        mPreviewStartInProgress = false;
1491        mPreviewEnabled = false;
1492        LOG_FUNCTION_NAME_EXIT;
1493
1494        return ret;
1495}
1496
1497/**
1498   @brief Sets ANativeWindow object.
1499
1500   Preview buffers provided to CameraHal via this object. DisplayAdapter will be interfacing with it
1501   to render buffers to display.
1502
1503   @param[in] window The ANativeWindow object created by Surface flinger
1504   @return NO_ERROR If the ANativeWindow object passes validation criteria
1505   @todo Define validation criteria for ANativeWindow object. Define error codes for scenarios
1506
1507 */
1508status_t CameraHal::setPreviewWindow(struct preview_stream_ops *window)
1509{
1510    status_t ret = NO_ERROR;
1511    CameraAdapter::BuffersDescriptor desc;
1512
1513    LOG_FUNCTION_NAME;
1514    mSetPreviewWindowCalled = true;
1515
1516   ///If the Camera service passes a null window, we destroy existing window and free the DisplayAdapter
1517    if(!window)
1518    {
1519        if(mDisplayAdapter.get() != NULL)
1520        {
1521            ///NULL window passed, destroy the display adapter if present
1522            CAMHAL_LOGEA("NULL window passed, destroying display adapter");
1523            mDisplayAdapter.clear();
1524            ///@remarks If there was a window previously existing, we usually expect another valid window to be passed by the client
1525            ///@remarks so, we will wait until it passes a valid window to begin the preview again
1526            mSetPreviewWindowCalled = false;
1527        }
1528        CAMHAL_LOGEA("NULL ANativeWindow passed to setPreviewWindow");
1529        return NO_ERROR;
1530    }else if(mDisplayAdapter.get() == NULL)
1531    {
1532        // Need to create the display adapter since it has not been created
1533        // Create display adapter
1534        mDisplayAdapter = new ANativeWindowDisplayAdapter();
1535        ret = NO_ERROR;
1536        if(!mDisplayAdapter.get() || ((ret=mDisplayAdapter->initialize())!=NO_ERROR))
1537        {
1538            if(ret!=NO_ERROR)
1539            {
1540                mDisplayAdapter.clear();
1541                CAMHAL_LOGEA("DisplayAdapter initialize failed");
1542                LOG_FUNCTION_NAME_EXIT;
1543                return ret;
1544            }
1545            else
1546            {
1547                CAMHAL_LOGEA("Couldn't create DisplayAdapter");
1548                LOG_FUNCTION_NAME_EXIT;
1549                return NO_MEMORY;
1550            }
1551        }
1552
1553        // DisplayAdapter needs to know where to get the CameraFrames from inorder to display
1554        // Since CameraAdapter is the one that provides the frames, set it as the frame provider for DisplayAdapter
1555        mDisplayAdapter->setFrameProvider(mCameraAdapter);
1556
1557        // Any dynamic errors that happen during the camera use case has to be propagated back to the application
1558        // via CAMERA_MSG_ERROR. AppCallbackNotifier is the class that  notifies such errors to the application
1559        // Set it as the error handler for the DisplayAdapter
1560        mDisplayAdapter->setErrorHandler(mAppCallbackNotifier.get());
1561
1562        // Update the display adapter with the new window that is passed from CameraService
1563        ret  = mDisplayAdapter->setPreviewWindow(window);
1564        if(ret!=NO_ERROR)
1565            {
1566            CAMHAL_LOGEB("DisplayAdapter setPreviewWindow returned error %d", ret);
1567            }
1568
1569        if(mPreviewStartInProgress)
1570        {
1571            CAMHAL_LOGDA("setPreviewWindow called when preview running");
1572            // Start the preview since the window is now available
1573            ret = startPreview();
1574        }
1575    }else
1576    {
1577        /* If mDisplayAdpater is already created. No need to do anything.
1578         * We get a surface handle directly now, so we can reconfigure surface
1579         * itself in DisplayAdapter if dimensions have changed
1580         */
1581    }
1582    LOG_FUNCTION_NAME_EXIT;
1583
1584    return ret;
1585
1586}
1587
1588
1589/**
1590   @brief Stop a previously started preview.
1591
1592   @param none
1593   @return none
1594
1595 */
1596void CameraHal::stopPreview()
1597{
1598    LOG_FUNCTION_NAME;
1599
1600    if(!previewEnabled() && !mDisplayPaused)
1601        {
1602        LOG_FUNCTION_NAME_EXIT;
1603        return;
1604        }
1605
1606    if(mDisplayPaused)
1607        {
1608        // Display is paused, which essentially means there is no preview active.
1609        // Note: this is done so that when stopPreview is called by client after
1610        // an image capture, we do not de-initialize the camera adapter and
1611        // restart over again.
1612        return;
1613        }
1614
1615    forceStopPreview();
1616
1617    // Reset Capture-Mode to default, so that when we switch from VideoRecording
1618    // to ImageCapture, CAPTURE_MODE is not left to VIDEO_MODE.
1619    CAMHAL_LOGDA("Resetting Capture-Mode to default");
1620    mParameters.set(TICameraParameters::KEY_CAP_MODE, "");
1621
1622    LOG_FUNCTION_NAME_EXIT;
1623}
1624
1625/**
1626   @brief Returns true if preview is enabled
1627
1628   @param none
1629   @return true If preview is running currently
1630         false If preview has been stopped
1631
1632 */
1633bool CameraHal::previewEnabled()
1634{
1635    LOG_FUNCTION_NAME;
1636
1637    return (mPreviewEnabled || mPreviewStartInProgress);
1638}
1639
1640/**
1641   @brief Start record mode.
1642
1643  When a record image is available a CAMERA_MSG_VIDEO_FRAME message is sent with
1644  the corresponding frame. Every record frame must be released by calling
1645  releaseRecordingFrame().
1646
1647   @param none
1648   @return NO_ERROR If recording could be started without any issues
1649   @todo Update the header with possible error values in failure scenarios
1650
1651 */
1652status_t CameraHal::startRecording( )
1653{
1654    int w, h;
1655    const char *valstr = NULL;
1656    bool restartPreviewRequired = false;
1657    status_t ret = NO_ERROR;
1658
1659    LOG_FUNCTION_NAME;
1660
1661
1662#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
1663
1664            gettimeofday(&mStartPreview, NULL);
1665
1666#endif
1667
1668    if(!previewEnabled())
1669        {
1670        return NO_INIT;
1671        }
1672
1673    valstr = mParameters.get(CameraParameters::KEY_RECORDING_HINT);
1674    if ( (valstr == NULL) ||
1675         ( (valstr != NULL) && (strcmp(valstr, CameraParameters::TRUE) != 0) ) )
1676        {
1677        restartPreviewRequired = setVideoModeParameters();
1678
1679        if(restartPreviewRequired)
1680            {
1681            ret = restartPreview();
1682            }
1683        }
1684
1685    if ( NO_ERROR == ret )
1686        {
1687         ret = mAppCallbackNotifier->initSharedVideoBuffers(mPreviewBufs, mPreviewOffsets, mPreviewFd, mPreviewLength, atoi(mCameraProperties->get(CameraProperties::REQUIRED_PREVIEW_BUFS)));
1688        }
1689
1690    if ( NO_ERROR == ret )
1691        {
1692         ret = mAppCallbackNotifier->startRecording();
1693        }
1694
1695    if ( NO_ERROR == ret )
1696        {
1697        ///Buffers for video capture (if different from preview) are expected to be allocated within CameraAdapter
1698         ret =  mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_VIDEO);
1699        }
1700
1701    if ( NO_ERROR == ret )
1702        {
1703        mRecordingEnabled = true;
1704        }
1705
1706    LOG_FUNCTION_NAME_EXIT;
1707
1708    return ret;
1709}
1710
1711/**
1712   @brief Set the camera parameters specific to Video Recording.
1713
1714   This function checks for the camera parameters which have to be set for recording.
1715   Video Recording needs CAPTURE_MODE to be VIDEO_MODE. This function sets it.
1716   This function also enables Video Recording specific functions like VSTAB & VNF.
1717
1718   @param none
1719   @return true if preview needs to be restarted for VIDEO_MODE parameters to take effect.
1720   @todo Modify the policies for enabling VSTAB & VNF usecase based later.
1721
1722 */
1723bool CameraHal::setVideoModeParameters()
1724{
1725    const char *valstr = NULL;
1726    bool restartPreviewRequired = false;
1727    status_t ret = NO_ERROR;
1728
1729    LOG_FUNCTION_NAME;
1730
1731    // Set CAPTURE_MODE to VIDEO_MODE, if not set already and Restart Preview
1732    valstr = mParameters.get(TICameraParameters::KEY_CAP_MODE);
1733    if ( (valstr == NULL) ||
1734        ( (valstr != NULL) && (strcmp(valstr, (const char *) TICameraParameters::VIDEO_MODE) != 0) ) )
1735        {
1736        CAMHAL_LOGDA("Set CAPTURE_MODE to VIDEO_MODE");
1737        mParameters.set(TICameraParameters::KEY_CAP_MODE, (const char *) TICameraParameters::VIDEO_MODE);
1738        restartPreviewRequired = true;
1739        }
1740
1741    // Check if CAPTURE_MODE is VIDEO_MODE, since VSTAB & VNF work only in VIDEO_MODE.
1742    valstr = mParameters.get(TICameraParameters::KEY_CAP_MODE);
1743    if (strcmp(valstr, (const char *) TICameraParameters::VIDEO_MODE) == 0)
1744        {
1745        // Enable VSTAB, if not enabled already
1746        valstr = mParameters.get(TICameraParameters::KEY_VSTAB);
1747        if ( (valstr == NULL) ||
1748            ( (valstr != NULL) && (strcmp(valstr, "1") != 0) ) )
1749            {
1750            CAMHAL_LOGDA("Enable VSTAB");
1751            mParameters.set(TICameraParameters::KEY_VSTAB, "1");
1752            restartPreviewRequired = true;
1753            }
1754
1755        // Enable VNF, if not enabled already
1756        valstr = mParameters.get(TICameraParameters::KEY_VNF);
1757        if ( (valstr == NULL) ||
1758            ( (valstr != NULL) && (strcmp(valstr, "1") != 0) ) )
1759            {
1760            CAMHAL_LOGDA("Enable VNF");
1761            mParameters.set(TICameraParameters::KEY_VNF, "1");
1762            restartPreviewRequired = true;
1763            }
1764
1765        // For VSTAB alone for 1080p resolution, padded width goes > 2048, which cannot be rendered by GPU.
1766        // In such case, there is support in Ducati for combination of VSTAB & VNF requiring padded width < 2048.
1767        // So we are forcefully enabling VNF, if VSTAB is enabled for 1080p resolution.
1768        valstr = mParameters.get(TICameraParameters::KEY_VSTAB);
1769        if ((valstr != NULL) && (strcmp(valstr, "1") == 0) && (mPreviewWidth == 1920))
1770            {
1771            CAMHAL_LOGDA("Force Enable VNF for 1080p");
1772            mParameters.set(TICameraParameters::KEY_VNF, "1");
1773            restartPreviewRequired = true;
1774            }
1775        }
1776
1777    LOG_FUNCTION_NAME_EXIT;
1778
1779    return restartPreviewRequired;
1780}
1781
1782/**
1783   @brief Reset the camera parameters specific to Video Recording.
1784
1785   This function resets CAPTURE_MODE and disables Recording specific functions like VSTAB & VNF.
1786
1787   @param none
1788   @return true if preview needs to be restarted for VIDEO_MODE parameters to take effect.
1789
1790 */
1791bool CameraHal::resetVideoModeParameters()
1792{
1793    const char *valstr = NULL;
1794    bool restartPreviewRequired = false;
1795    status_t ret = NO_ERROR;
1796
1797    LOG_FUNCTION_NAME;
1798
1799    // Set CAPTURE_MODE to VIDEO_MODE, if not set already and Restart Preview
1800    valstr = mParameters.get(TICameraParameters::KEY_CAP_MODE);
1801    if ( (valstr != NULL) && (strcmp(valstr, (const char *) TICameraParameters::VIDEO_MODE) == 0) )
1802        {
1803        CAMHAL_LOGDA("Reset Capture-Mode to default");
1804        mParameters.set(TICameraParameters::KEY_CAP_MODE, "");
1805        restartPreviewRequired = true;
1806        }
1807
1808    // Enable VSTAB, if not enabled already
1809    valstr = mParameters.get(TICameraParameters::KEY_VSTAB);
1810    if (  (valstr != NULL) && (strcmp(valstr, "1") == 0) )
1811        {
1812        CAMHAL_LOGDA("Disable VSTAB");
1813        mParameters.set(TICameraParameters::KEY_VSTAB, "0");
1814        restartPreviewRequired = true;
1815        }
1816
1817    // Enable VNF, if not enabled already
1818    valstr = mParameters.get(TICameraParameters::KEY_VNF);
1819    if (  (valstr != NULL) && (strcmp(valstr, "1") == 0) )
1820        {
1821        CAMHAL_LOGDA("Disable VNF");
1822        mParameters.set(TICameraParameters::KEY_VNF, "0");
1823        restartPreviewRequired = true;
1824        }
1825
1826    LOG_FUNCTION_NAME_EXIT;
1827
1828    return restartPreviewRequired;
1829}
1830
1831/**
1832   @brief Restart the preview with setParameter.
1833
1834   This function restarts preview, for some VIDEO_MODE parameters to take effect.
1835
1836   @param none
1837   @return NO_ERROR If recording parameters could be set without any issues
1838
1839 */
1840status_t CameraHal::restartPreview()
1841{
1842    const char *valstr = NULL;
1843    char tmpvalstr[30];
1844    status_t ret = NO_ERROR;
1845
1846    LOG_FUNCTION_NAME;
1847
1848    // Retain CAPTURE_MODE before calling stopPreview(), since it is reset in stopPreview().
1849    tmpvalstr[0] = 0;
1850    valstr = mParameters.get(TICameraParameters::KEY_CAP_MODE);
1851    if(valstr != NULL)
1852        {
1853        if(sizeof(tmpvalstr) < (strlen(valstr)+1))
1854            {
1855            return -EINVAL;
1856            }
1857
1858        strncpy(tmpvalstr, valstr, sizeof(tmpvalstr));
1859        tmpvalstr[sizeof(tmpvalstr)-1] = 0;
1860        }
1861
1862    stopPreview();
1863
1864    {
1865        Mutex::Autolock lock(mLock);
1866        mParameters.set(TICameraParameters::KEY_CAP_MODE, tmpvalstr);
1867        mCameraAdapter->setParameters(mParameters);
1868    }
1869
1870    ret = startPreview();
1871
1872    LOG_FUNCTION_NAME_EXIT;
1873
1874    return ret;
1875}
1876
1877/**
1878   @brief Stop a previously started recording.
1879
1880   @param none
1881   @return none
1882
1883 */
1884void CameraHal::stopRecording()
1885{
1886    LOG_FUNCTION_NAME;
1887
1888    if (!mRecordingEnabled )
1889        {
1890        return;
1891        }
1892
1893    mAppCallbackNotifier->stopRecording();
1894
1895    mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_VIDEO);
1896
1897    mRecordingEnabled = false;
1898
1899    LOG_FUNCTION_NAME_EXIT;
1900}
1901
1902/**
1903   @brief Returns true if recording is enabled.
1904
1905   @param none
1906   @return true If recording is currently running
1907         false If recording has been stopped
1908
1909 */
1910int CameraHal::recordingEnabled()
1911{
1912    LOG_FUNCTION_NAME;
1913
1914    LOG_FUNCTION_NAME_EXIT;
1915
1916    return mRecordingEnabled;
1917}
1918
1919/**
1920   @brief Release a record frame previously returned by CAMERA_MSG_VIDEO_FRAME.
1921
1922   @param[in] mem MemoryBase pointer to the frame being released. Must be one of the buffers
1923               previously given by CameraHal
1924   @return none
1925
1926 */
1927void CameraHal::releaseRecordingFrame(const void* mem)
1928{
1929    LOG_FUNCTION_NAME;
1930
1931    //CAMHAL_LOGDB(" 0x%x", mem->pointer());
1932
1933    if ( ( mRecordingEnabled ) && mem != NULL)
1934    {
1935        mAppCallbackNotifier->releaseRecordingFrame(mem);
1936    }
1937
1938    LOG_FUNCTION_NAME_EXIT;
1939
1940    return;
1941}
1942
1943/**
1944   @brief Start auto focus
1945
1946   This call asynchronous.
1947   The notification callback routine is called with CAMERA_MSG_FOCUS once when
1948   focusing is complete. autoFocus() will be called again if another auto focus is
1949   needed.
1950
1951   @param none
1952   @return NO_ERROR
1953   @todo Define the error codes if the focus is not locked
1954
1955 */
1956status_t CameraHal::autoFocus()
1957{
1958    status_t ret = NO_ERROR;
1959
1960#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
1961
1962    gettimeofday(&mStartFocus, NULL);
1963
1964#endif
1965
1966
1967    LOG_FUNCTION_NAME;
1968
1969    if ( NULL != mCameraAdapter )
1970        {
1971
1972#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
1973
1974    //pass the autoFocus timestamp along with the command to camera adapter
1975    ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_PERFORM_AUTOFOCUS, ( int ) &mStartFocus);
1976
1977#else
1978
1979    ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_PERFORM_AUTOFOCUS);
1980
1981#endif
1982
1983        }
1984    else
1985        {
1986            ret = -1;
1987        }
1988
1989    LOG_FUNCTION_NAME_EXIT;
1990
1991    return ret;
1992}
1993
1994/**
1995   @brief Cancels auto-focus function.
1996
1997   If the auto-focus is still in progress, this function will cancel it.
1998   Whether the auto-focus is in progress or not, this function will return the
1999   focus position to the default. If the camera does not support auto-focus, this is a no-op.
2000
2001
2002   @param none
2003   @return NO_ERROR If the cancel succeeded
2004   @todo Define error codes if cancel didnt succeed
2005
2006 */
2007status_t CameraHal::cancelAutoFocus()
2008{
2009    LOG_FUNCTION_NAME;
2010    if( NULL != mCameraAdapter )
2011    {
2012        mCameraAdapter->sendCommand(CameraAdapter::CAMERA_CANCEL_AUTOFOCUS);
2013    }
2014    LOG_FUNCTION_NAME_EXIT;
2015    return NO_ERROR;
2016}
2017
2018void CameraHal::setEventProvider(int32_t eventMask, MessageNotifier * eventNotifier)
2019{
2020
2021    LOG_FUNCTION_NAME;
2022
2023    if ( NULL != mEventProvider )
2024        {
2025        mEventProvider->disableEventNotification(CameraHalEvent::ALL_EVENTS);
2026        delete mEventProvider;
2027        mEventProvider = NULL;
2028        }
2029
2030    mEventProvider = new EventProvider(eventNotifier, this, eventCallbackRelay);
2031    if ( NULL == mEventProvider )
2032        {
2033        CAMHAL_LOGEA("Error in creating EventProvider");
2034        }
2035    else
2036        {
2037        mEventProvider->enableEventNotification(eventMask);
2038        }
2039
2040    LOG_FUNCTION_NAME_EXIT;
2041}
2042
2043void CameraHal::eventCallbackRelay(CameraHalEvent* event)
2044{
2045    LOG_FUNCTION_NAME;
2046
2047    CameraHal *appcbn = ( CameraHal * ) (event->mCookie);
2048    appcbn->eventCallback(event );
2049
2050    LOG_FUNCTION_NAME_EXIT;
2051}
2052
2053void CameraHal::eventCallback(CameraHalEvent* event)
2054{
2055    LOG_FUNCTION_NAME;
2056
2057    if ( NULL != event )
2058        {
2059        switch( event->mEventType )
2060            {
2061            case CameraHalEvent::EVENT_FOCUS_LOCKED:
2062            case CameraHalEvent::EVENT_FOCUS_ERROR:
2063                {
2064                if ( mBracketingEnabled )
2065                    {
2066                    startImageBracketing();
2067                    }
2068                break;
2069                }
2070            default:
2071                {
2072                break;
2073                }
2074            };
2075        }
2076
2077    LOG_FUNCTION_NAME_EXIT;
2078}
2079
2080status_t CameraHal::startImageBracketing()
2081{
2082        status_t ret = NO_ERROR;
2083        CameraFrame frame;
2084        CameraAdapter::BuffersDescriptor desc;
2085
2086#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
2087
2088        gettimeofday(&mStartCapture, NULL);
2089
2090#endif
2091
2092        LOG_FUNCTION_NAME;
2093
2094        if(!previewEnabled() && !mDisplayPaused)
2095            {
2096            LOG_FUNCTION_NAME_EXIT;
2097            return NO_INIT;
2098            }
2099
2100        if ( !mBracketingEnabled )
2101            {
2102            return ret;
2103            }
2104
2105        if ( NO_ERROR == ret )
2106            {
2107            mBracketingRunning = true;
2108            }
2109
2110        if (  (NO_ERROR == ret) && ( NULL != mCameraAdapter ) )
2111            {
2112            ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE,
2113                                              ( int ) &frame,
2114                                              ( mBracketRangeNegative + 1 ));
2115
2116            if ( NO_ERROR != ret )
2117                {
2118                CAMHAL_LOGEB("CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE returned error 0x%x", ret);
2119                }
2120            }
2121
2122        if ( NO_ERROR == ret )
2123            {
2124            if ( NULL != mAppCallbackNotifier.get() )
2125                 {
2126                 mAppCallbackNotifier->setBurst(true);
2127                 }
2128            }
2129
2130        if ( NO_ERROR == ret )
2131            {
2132            mParameters.getPictureSize(( int * ) &frame.mWidth,
2133                                       ( int * ) &frame.mHeight);
2134
2135            ret = allocImageBufs(frame.mWidth,
2136                                 frame.mHeight,
2137                                 frame.mLength,
2138                                 mParameters.getPictureFormat(),
2139                                 ( mBracketRangeNegative + 1 ));
2140            if ( NO_ERROR != ret )
2141                {
2142                CAMHAL_LOGEB("allocImageBufs returned error 0x%x", ret);
2143                }
2144            }
2145
2146        if (  (NO_ERROR == ret) && ( NULL != mCameraAdapter ) )
2147            {
2148
2149            desc.mBuffers = mImageBufs;
2150            desc.mOffsets = mImageOffsets;
2151            desc.mFd = mImageFd;
2152            desc.mLength = mImageLength;
2153            desc.mCount = ( size_t ) ( mBracketRangeNegative + 1 );
2154            desc.mMaxQueueable = ( size_t ) ( mBracketRangeNegative + 1 );
2155
2156            ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_IMAGE_CAPTURE,
2157                                              ( int ) &desc);
2158
2159            if ( NO_ERROR == ret )
2160                {
2161
2162#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
2163
2164                 //pass capture timestamp along with the camera adapter command
2165                ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_BRACKET_CAPTURE,  ( mBracketRangePositive + 1 ),  (int) &mStartCapture);
2166
2167#else
2168
2169                ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_BRACKET_CAPTURE, ( mBracketRangePositive + 1 ));
2170
2171#endif
2172
2173                }
2174            }
2175
2176        return ret;
2177}
2178
2179status_t CameraHal::stopImageBracketing()
2180{
2181        status_t ret = NO_ERROR;
2182
2183        LOG_FUNCTION_NAME;
2184
2185        if ( !mBracketingRunning )
2186            {
2187            return ret;
2188            }
2189
2190        if ( NO_ERROR == ret )
2191            {
2192            mBracketingRunning = false;
2193            }
2194
2195        if(!previewEnabled() && !mDisplayPaused)
2196            {
2197            return NO_INIT;
2198            }
2199
2200        if ( NO_ERROR == ret )
2201            {
2202            ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_BRACKET_CAPTURE);
2203            }
2204
2205        LOG_FUNCTION_NAME_EXIT;
2206
2207        return ret;
2208}
2209
2210/**
2211   @brief Take a picture.
2212
2213   @param none
2214   @return NO_ERROR If able to switch to image capture
2215   @todo Define error codes if unable to switch to image capture
2216
2217 */
2218status_t CameraHal::takePicture( )
2219{
2220    status_t ret = NO_ERROR;
2221    CameraFrame frame;
2222    CameraAdapter::BuffersDescriptor desc;
2223    int burst;
2224    unsigned int bufferCount = 1;
2225
2226    Mutex::Autolock lock(mLock);
2227
2228#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
2229
2230    gettimeofday(&mStartCapture, NULL);
2231
2232#endif
2233
2234    LOG_FUNCTION_NAME;
2235
2236    if(!previewEnabled() && !mDisplayPaused)
2237        {
2238        LOG_FUNCTION_NAME_EXIT;
2239        return NO_INIT;
2240        }
2241
2242    //If capture has already started, then queue this call for later execution
2243    if ( mCameraAdapter->getState() == CameraAdapter::CAPTURE_STATE &&
2244         mCameraAdapter->getNextState() != CameraAdapter::PREVIEW_STATE) {
2245        return NO_INIT;
2246    }
2247
2248    if ( !mBracketingRunning )
2249        {
2250
2251         if ( NO_ERROR == ret )
2252            {
2253            burst = mParameters.getInt(TICameraParameters::KEY_BURST);
2254            }
2255
2256         //Allocate all buffers only in burst capture case
2257         if ( burst > 1 )
2258             {
2259             bufferCount = CameraHal::NO_BUFFERS_IMAGE_CAPTURE;
2260             if ( NULL != mAppCallbackNotifier.get() )
2261                 {
2262                 mAppCallbackNotifier->setBurst(true);
2263                 }
2264             }
2265         else
2266             {
2267             if ( NULL != mAppCallbackNotifier.get() )
2268                 {
2269                 mAppCallbackNotifier->setBurst(false);
2270                 }
2271             }
2272
2273        //Pause Preview during capture
2274        if ( (NO_ERROR == ret) && ( NULL != mDisplayAdapter.get() ) && ( burst < 1 ) )
2275            {
2276            mDisplayPaused = true;
2277            mPreviewEnabled = false;
2278            ret = mDisplayAdapter->pauseDisplay(mDisplayPaused);
2279
2280#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
2281
2282            mDisplayAdapter->setSnapshotTimeRef(&mStartCapture);
2283
2284#endif
2285            // since preview is paused we should stop sending preview frames too
2286            if(mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME)
2287                {
2288                    mAppCallbackNotifier->disableMsgType (CAMERA_MSG_PREVIEW_FRAME);
2289                }
2290            }
2291
2292        if (  (NO_ERROR == ret) && ( NULL != mCameraAdapter ) )
2293            {
2294
2295            //Configure the correct picture resolution now if the capture mode is not set
2296            if(mParameters.get(TICameraParameters::KEY_CAP_MODE) == NULL)
2297                {
2298                ret = mCameraAdapter->setParameters(mParameters);
2299                }
2300
2301            if ( NO_ERROR == ret )
2302                ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE,
2303                                                  ( int ) &frame,
2304                                                  bufferCount);
2305
2306            if ( NO_ERROR != ret )
2307                {
2308                CAMHAL_LOGEB("CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE returned error 0x%x", ret);
2309                }
2310            }
2311
2312        if ( NO_ERROR == ret )
2313            {
2314            mParameters.getPictureSize(( int * ) &frame.mWidth,
2315                                       ( int * ) &frame.mHeight);
2316
2317            ret = allocImageBufs(frame.mWidth,
2318                                 frame.mHeight,
2319                                 frame.mLength,
2320                                 mParameters.getPictureFormat(),
2321                                 bufferCount);
2322            if ( NO_ERROR != ret )
2323                {
2324                CAMHAL_LOGEB("allocImageBufs returned error 0x%x", ret);
2325                }
2326            }
2327
2328        if (  (NO_ERROR == ret) && ( NULL != mCameraAdapter ) )
2329            {
2330            desc.mBuffers = mImageBufs;
2331            desc.mOffsets = mImageOffsets;
2332            desc.mFd = mImageFd;
2333            desc.mLength = mImageLength;
2334            desc.mCount = ( size_t ) bufferCount;
2335            desc.mMaxQueueable = ( size_t ) bufferCount;
2336
2337            ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_IMAGE_CAPTURE,
2338                                              ( int ) &desc);
2339            }
2340        }
2341    else
2342        {
2343        mBracketingRunning = false;
2344        }
2345
2346    if ( ( NO_ERROR == ret ) && ( NULL != mCameraAdapter ) )
2347        {
2348
2349#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
2350
2351         //pass capture timestamp along with the camera adapter command
2352        ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_IMAGE_CAPTURE,  (int) &mStartCapture);
2353
2354#else
2355
2356        ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_IMAGE_CAPTURE);
2357
2358#endif
2359
2360        }
2361
2362    return ret;
2363}
2364
2365/**
2366   @brief Cancel a picture that was started with takePicture.
2367
2368   Calling this method when no picture is being taken is a no-op.
2369
2370   @param none
2371   @return NO_ERROR If cancel succeeded. Cancel can succeed if image callback is not sent
2372   @todo Define error codes
2373
2374 */
2375status_t CameraHal::cancelPicture( )
2376{
2377    LOG_FUNCTION_NAME;
2378
2379    Mutex::Autolock lock(mLock);
2380
2381    mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_IMAGE_CAPTURE);
2382
2383    return NO_ERROR;
2384}
2385
2386/**
2387   @brief Return the camera parameters.
2388
2389   @param none
2390   @return Currently configured camera parameters
2391
2392 */
2393char* CameraHal::getParameters()
2394{
2395    CameraParameters params;
2396    String8 params_str8;
2397    char* params_string;
2398
2399    LOG_FUNCTION_NAME;
2400
2401    params = mParameters;
2402    if( NULL != mCameraAdapter )
2403    {
2404        mCameraAdapter->getParameters(params);
2405    }
2406
2407    params_str8 = params.flatten();
2408    // camera service frees this string...
2409    params_string = (char*) malloc(sizeof(char) * (params_str8.length()+1));
2410    strcpy(params_string, params_str8.string());
2411
2412    LOG_FUNCTION_NAME_EXIT;
2413
2414    ///Return the current set of parameters
2415
2416    return params_string;
2417}
2418
2419void CameraHal::putParameters(char *parms)
2420{
2421    free(parms);
2422}
2423
2424/**
2425   @brief Send command to camera driver.
2426
2427   @param none
2428   @return NO_ERROR If the command succeeds
2429   @todo Define the error codes that this function can return
2430
2431 */
2432status_t CameraHal::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2)
2433{
2434    status_t ret = NO_ERROR;
2435
2436    LOG_FUNCTION_NAME;
2437
2438
2439    if ( ( NO_ERROR == ret ) && ( NULL == mCameraAdapter ) )
2440        {
2441        CAMHAL_LOGEA("No CameraAdapter instance");
2442        ret = -EINVAL;
2443        }
2444
2445    if ( ( NO_ERROR == ret ) && ( !previewEnabled() ))
2446        {
2447        CAMHAL_LOGEA("Preview is not running");
2448        ret = -EINVAL;
2449        }
2450
2451    if ( NO_ERROR == ret )
2452        {
2453        switch(cmd)
2454            {
2455            case CAMERA_CMD_START_SMOOTH_ZOOM:
2456
2457                ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_SMOOTH_ZOOM, arg1);
2458
2459                break;
2460            case CAMERA_CMD_STOP_SMOOTH_ZOOM:
2461
2462                ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_SMOOTH_ZOOM);
2463
2464            case CAMERA_CMD_START_FACE_DETECTION:
2465
2466                ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_FD);
2467
2468                break;
2469
2470            case CAMERA_CMD_STOP_FACE_DETECTION:
2471
2472                ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_FD);
2473
2474                break;
2475
2476            default:
2477                break;
2478            };
2479        }
2480
2481    LOG_FUNCTION_NAME_EXIT;
2482
2483    return ret;
2484}
2485
2486/**
2487   @brief Release the hardware resources owned by this object.
2488
2489   Note that this is *not* done in the destructor.
2490
2491   @param none
2492   @return none
2493
2494 */
2495void CameraHal::release()
2496{
2497    LOG_FUNCTION_NAME;
2498    ///@todo Investigate on how release is used by CameraService. Vaguely remember that this is called
2499    ///just before CameraHal object destruction
2500    deinitialize();
2501    LOG_FUNCTION_NAME_EXIT;
2502}
2503
2504
2505/**
2506   @brief Dump state of the camera hardware
2507
2508   @param[in] fd    File descriptor
2509   @param[in] args  Arguments
2510   @return NO_ERROR Dump succeeded
2511   @todo  Error codes for dump fail
2512
2513 */
2514status_t  CameraHal::dump(int fd) const
2515{
2516    LOG_FUNCTION_NAME;
2517    ///Implement this method when the h/w dump function is supported on Ducati side
2518    return NO_ERROR;
2519}
2520
2521/*-------------Camera Hal Interface Method definitions ENDS here--------------------*/
2522
2523
2524
2525
2526/*-------------Camera Hal Internal Method definitions STARTS here--------------------*/
2527
2528/**
2529   @brief Constructor of CameraHal
2530
2531   Member variables are initialized here.  No allocations should be done here as we
2532   don't use c++ exceptions in the code.
2533
2534 */
2535CameraHal::CameraHal(int cameraId)
2536{
2537    LOG_FUNCTION_NAME;
2538
2539    ///Initialize all the member variables to their defaults
2540    mPreviewEnabled = false;
2541    mPreviewBufs = NULL;
2542    mImageBufs = NULL;
2543    mBufProvider = NULL;
2544    mPreviewStartInProgress = false;
2545    mVideoBufs = NULL;
2546    mVideoBufProvider = NULL;
2547    mRecordingEnabled = false;
2548    mDisplayPaused = false;
2549    mSetPreviewWindowCalled = false;
2550    mMsgEnabled = 0;
2551    mAppCallbackNotifier = NULL;
2552    mMemoryManager = NULL;
2553    mCameraAdapter = NULL;
2554    mBracketingEnabled = false;
2555    mBracketingRunning = false;
2556    mEventProvider = NULL;
2557    mBracketRangePositive = 1;
2558    mBracketRangeNegative = 1;
2559    mMaxZoomSupported = 0;
2560    mShutterEnabled = true;
2561    mMeasurementEnabled = false;
2562    mPreviewDataBufs = NULL;
2563    mCameraProperties = NULL;
2564    mCurrentTime = 0;
2565    mFalsePreview = 0;
2566    mImageOffsets = NULL;
2567    mImageLength = 0;
2568    mImageFd = 0;
2569    mVideoOffsets = NULL;
2570    mVideoFd = 0;
2571    mVideoLength = 0;
2572    mPreviewDataOffsets = NULL;
2573    mPreviewDataFd = 0;
2574    mPreviewDataLength = 0;
2575    mPreviewFd = 0;
2576    mPreviewWidth = 0;
2577    mPreviewHeight = 0;
2578    mPreviewLength = 0;
2579    mPreviewOffsets = NULL;
2580    mPreviewRunning = 0;
2581    mPreviewStateOld = 0;
2582    mRecordingEnabled = 0;
2583    mRecordEnabled = 0;
2584    mSensorListener = NULL;
2585
2586#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
2587
2588    //Initialize the CameraHAL constructor timestamp, which is used in the
2589    // PPM() method as time reference if the user does not supply one.
2590    gettimeofday(&ppm_start, NULL);
2591
2592#endif
2593
2594    mCameraIndex = cameraId;
2595
2596    LOG_FUNCTION_NAME_EXIT;
2597}
2598
2599/**
2600   @brief Destructor of CameraHal
2601
2602   This function simply calls deinitialize() to free up memory allocate during construct
2603   phase
2604 */
2605CameraHal::~CameraHal()
2606{
2607    LOG_FUNCTION_NAME;
2608
2609    ///Call de-initialize here once more - it is the last chance for us to relinquish all the h/w and s/w resources
2610    deinitialize();
2611
2612    if ( NULL != mEventProvider )
2613        {
2614        mEventProvider->disableEventNotification(CameraHalEvent::ALL_EVENTS);
2615        delete mEventProvider;
2616        mEventProvider = NULL;
2617        }
2618
2619    /// Free the callback notifier
2620    mAppCallbackNotifier.clear();
2621
2622    /// Free the memory manager
2623    mMemoryManager.clear();
2624
2625    /// Free the display adapter
2626    mDisplayAdapter.clear();
2627
2628    if ( NULL != mCameraAdapter ) {
2629        int strongCount = mCameraAdapter->getStrongCount();
2630
2631        mCameraAdapter->decStrong(mCameraAdapter);
2632
2633        mCameraAdapter = NULL;
2634    }
2635
2636    LOG_FUNCTION_NAME_EXIT;
2637}
2638
2639/**
2640   @brief Initialize the Camera HAL
2641
2642   Creates CameraAdapter, AppCallbackNotifier, DisplayAdapter and MemoryManager
2643
2644   @param None
2645   @return NO_ERROR - On success
2646         NO_MEMORY - On failure to allocate memory for any of the objects
2647   @remarks Camera Hal internal function
2648
2649 */
2650
2651status_t CameraHal::initialize(CameraProperties::Properties* properties)
2652{
2653    LOG_FUNCTION_NAME;
2654
2655    int sensor_index = 0;
2656
2657    mLastPreviewFramerate = 0;
2658
2659    ///Initialize the event mask used for registering an event provider for AppCallbackNotifier
2660    ///Currently, registering all events as to be coming from CameraAdapter
2661    int32_t eventMask = CameraHalEvent::ALL_EVENTS;
2662
2663    // Get my camera properties
2664    mCameraProperties = properties;
2665
2666    if(!mCameraProperties)
2667    {
2668        goto fail_loop;
2669    }
2670
2671    // Dump the properties of this Camera
2672    // will only print if DEBUG macro is defined
2673    mCameraProperties->dump();
2674
2675    if (strcmp(CameraProperties::DEFAULT_VALUE, mCameraProperties->get(CameraProperties::CAMERA_SENSOR_INDEX)) != 0 )
2676        {
2677        sensor_index = atoi(mCameraProperties->get(CameraProperties::CAMERA_SENSOR_INDEX));
2678        }
2679
2680    CAMHAL_LOGDB("Sensor index %d", sensor_index);
2681
2682    mCameraAdapter = CameraAdapter_Factory();
2683    if ( ( NULL == mCameraAdapter ) || (mCameraAdapter->initialize(properties, sensor_index)!=NO_ERROR))
2684        {
2685        CAMHAL_LOGEA("Unable to create or initialize CameraAdapter");
2686        mCameraAdapter = NULL;
2687        goto fail_loop;
2688        }
2689
2690    mCameraAdapter->incStrong(mCameraAdapter);
2691    mCameraAdapter->registerImageReleaseCallback(releaseImageBuffers, (void *) this);
2692    mCameraAdapter->registerEndCaptureCallback(endImageCapture, (void *)this);
2693
2694    if(!mAppCallbackNotifier.get())
2695        {
2696        /// Create the callback notifier
2697        mAppCallbackNotifier = new AppCallbackNotifier();
2698        if( ( NULL == mAppCallbackNotifier.get() ) || ( mAppCallbackNotifier->initialize() != NO_ERROR))
2699            {
2700            CAMHAL_LOGEA("Unable to create or initialize AppCallbackNotifier");
2701            goto fail_loop;
2702            }
2703        }
2704
2705    if(!mMemoryManager.get())
2706        {
2707        /// Create Memory Manager
2708        mMemoryManager = new MemoryManager();
2709        if( ( NULL == mMemoryManager.get() ) || ( mMemoryManager->initialize() != NO_ERROR))
2710            {
2711            CAMHAL_LOGEA("Unable to create or initialize MemoryManager");
2712            goto fail_loop;
2713            }
2714        }
2715
2716    ///Setup the class dependencies...
2717
2718    ///AppCallbackNotifier has to know where to get the Camera frames and the events like auto focus lock etc from.
2719    ///CameraAdapter is the one which provides those events
2720    ///Set it as the frame and event providers for AppCallbackNotifier
2721    ///@remarks  setEventProvider API takes in a bit mask of events for registering a provider for the different events
2722    ///         That way, if events can come from DisplayAdapter in future, we will be able to add it as provider
2723    ///         for any event
2724    mAppCallbackNotifier->setEventProvider(eventMask, mCameraAdapter);
2725    mAppCallbackNotifier->setFrameProvider(mCameraAdapter);
2726
2727    ///Any dynamic errors that happen during the camera use case has to be propagated back to the application
2728    ///via CAMERA_MSG_ERROR. AppCallbackNotifier is the class that  notifies such errors to the application
2729    ///Set it as the error handler for CameraAdapter
2730    mCameraAdapter->setErrorHandler(mAppCallbackNotifier.get());
2731
2732    ///Start the callback notifier
2733    if(mAppCallbackNotifier->start() != NO_ERROR)
2734      {
2735        CAMHAL_LOGEA("Couldn't start AppCallbackNotifier");
2736        goto fail_loop;
2737      }
2738
2739    CAMHAL_LOGDA("Started AppCallbackNotifier..");
2740    mAppCallbackNotifier->setMeasurements(mMeasurementEnabled);
2741
2742    ///Initialize default parameters
2743    initDefaultParameters();
2744
2745
2746    if ( setParameters(mParameters) != NO_ERROR )
2747        {
2748        CAMHAL_LOGEA("Failed to set default parameters?!");
2749        }
2750
2751    // register for sensor events
2752    mSensorListener = new SensorListener();
2753    if (mSensorListener.get()) {
2754        if (mSensorListener->initialize() == NO_ERROR) {
2755            mSensorListener->setCallbacks(orientation_cb, this);
2756            mSensorListener->enableSensor(SensorListener::SENSOR_ORIENTATION);
2757        } else {
2758            CAMHAL_LOGEA("Error initializing SensorListener. not fatal, continuing");
2759            mSensorListener.clear();
2760            mSensorListener = NULL;
2761        }
2762    }
2763
2764    LOG_FUNCTION_NAME_EXIT;
2765
2766    return NO_ERROR;
2767
2768    fail_loop:
2769
2770        ///Free up the resources because we failed somewhere up
2771        deinitialize();
2772        LOG_FUNCTION_NAME_EXIT;
2773
2774        return NO_MEMORY;
2775
2776}
2777
2778bool CameraHal::isResolutionValid(unsigned int width, unsigned int height, const char *supportedResolutions)
2779{
2780    bool ret = true;
2781    status_t status = NO_ERROR;
2782    char tmpBuffer[PARAM_BUFFER + 1];
2783    char *pos = NULL;
2784
2785    LOG_FUNCTION_NAME;
2786
2787    if ( NULL == supportedResolutions )
2788        {
2789        CAMHAL_LOGEA("Invalid supported resolutions string");
2790        ret = false;
2791        goto exit;
2792        }
2793
2794    status = snprintf(tmpBuffer, PARAM_BUFFER, "%dx%d", width, height);
2795    if ( 0 > status )
2796        {
2797        CAMHAL_LOGEA("Error encountered while generating validation string");
2798        ret = false;
2799        goto exit;
2800        }
2801
2802    pos = strstr(supportedResolutions, tmpBuffer);
2803    if ( NULL == pos )
2804        {
2805        ret = false;
2806        }
2807    else
2808        {
2809        ret = true;
2810        }
2811
2812exit:
2813
2814    LOG_FUNCTION_NAME_EXIT;
2815
2816    return ret;
2817}
2818
2819bool CameraHal::isParameterValid(const char *param, const char *supportedParams)
2820{
2821    bool ret = true;
2822    char *pos = NULL;
2823
2824    LOG_FUNCTION_NAME;
2825
2826    if ( NULL == supportedParams )
2827        {
2828        CAMHAL_LOGEA("Invalid supported parameters string");
2829        ret = false;
2830        goto exit;
2831        }
2832
2833    if ( NULL == param )
2834        {
2835        CAMHAL_LOGEA("Invalid parameter string");
2836        ret = false;
2837        goto exit;
2838        }
2839
2840    pos = strstr(supportedParams, param);
2841    if ( NULL == pos )
2842        {
2843        ret = false;
2844        }
2845    else
2846        {
2847        ret = true;
2848        }
2849
2850exit:
2851
2852    LOG_FUNCTION_NAME_EXIT;
2853
2854    return ret;
2855}
2856
2857bool CameraHal::isParameterValid(int param, const char *supportedParams)
2858{
2859    bool ret = true;
2860    char *pos = NULL;
2861    status_t status;
2862    char tmpBuffer[PARAM_BUFFER + 1];
2863
2864    LOG_FUNCTION_NAME;
2865
2866    if ( NULL == supportedParams )
2867        {
2868        CAMHAL_LOGEA("Invalid supported parameters string");
2869        ret = false;
2870        goto exit;
2871        }
2872
2873    status = snprintf(tmpBuffer, PARAM_BUFFER, "%d", param);
2874    if ( 0 > status )
2875        {
2876        CAMHAL_LOGEA("Error encountered while generating validation string");
2877        ret = false;
2878        goto exit;
2879        }
2880
2881    pos = strstr(supportedParams, tmpBuffer);
2882    if ( NULL == pos )
2883        {
2884        ret = false;
2885        }
2886    else
2887        {
2888        ret = true;
2889        }
2890
2891exit:
2892
2893    LOG_FUNCTION_NAME_EXIT;
2894
2895    return ret;
2896}
2897
2898status_t CameraHal::parseResolution(const char *resStr, int &width, int &height)
2899{
2900    status_t ret = NO_ERROR;
2901    char *ctx, *pWidth, *pHeight;
2902    const char *sep = "x";
2903    char *tmp = NULL;
2904
2905    LOG_FUNCTION_NAME;
2906
2907    if ( NULL == resStr )
2908        {
2909        return -EINVAL;
2910        }
2911
2912    //This fixes "Invalid input resolution"
2913    char *resStr_copy = (char *)malloc(strlen(resStr) + 1);
2914    if ( NULL!=resStr_copy ) {
2915    if ( NO_ERROR == ret )
2916        {
2917        strcpy(resStr_copy, resStr);
2918        pWidth = strtok_r( (char *) resStr_copy, sep, &ctx);
2919
2920        if ( NULL != pWidth )
2921            {
2922            width = atoi(pWidth);
2923            }
2924        else
2925            {
2926            CAMHAL_LOGEB("Invalid input resolution %s", resStr);
2927            ret = -EINVAL;
2928            }
2929        }
2930
2931    if ( NO_ERROR == ret )
2932        {
2933        pHeight = strtok_r(NULL, sep, &ctx);
2934
2935        if ( NULL != pHeight )
2936            {
2937            height = atoi(pHeight);
2938            }
2939        else
2940            {
2941            CAMHAL_LOGEB("Invalid input resolution %s", resStr);
2942            ret = -EINVAL;
2943            }
2944        }
2945
2946        free(resStr_copy);
2947        resStr_copy = NULL;
2948     }
2949    LOG_FUNCTION_NAME_EXIT;
2950
2951    return ret;
2952}
2953
2954void CameraHal::insertSupportedParams()
2955{
2956    char tmpBuffer[PARAM_BUFFER + 1];
2957
2958    LOG_FUNCTION_NAME;
2959
2960    CameraParameters &p = mParameters;
2961
2962    ///Set the name of the camera
2963    p.set(TICameraParameters::KEY_CAMERA_NAME, mCameraProperties->get(CameraProperties::CAMERA_NAME));
2964
2965    mMaxZoomSupported = atoi(mCameraProperties->get(CameraProperties::SUPPORTED_ZOOM_STAGES));
2966
2967    p.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_SIZES));
2968    p.set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_FORMATS));
2969    p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_SIZES));
2970    p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FORMATS));
2971    p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FRAME_RATES));
2972    p.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_THUMBNAIL_SIZES));
2973    p.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE, mCameraProperties->get(CameraProperties::SUPPORTED_WHITE_BALANCE));
2974    p.set(CameraParameters::KEY_SUPPORTED_EFFECTS, mCameraProperties->get(CameraProperties::SUPPORTED_EFFECTS));
2975    p.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES, mCameraProperties->get(CameraProperties::SUPPORTED_SCENE_MODES));
2976    p.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, mCameraProperties->get(CameraProperties::SUPPORTED_FLASH_MODES));
2977    p.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES, mCameraProperties->get(CameraProperties::SUPPORTED_FOCUS_MODES));
2978    p.set(CameraParameters::KEY_SUPPORTED_ANTIBANDING, mCameraProperties->get(CameraProperties::SUPPORTED_ANTIBANDING));
2979    p.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION, mCameraProperties->get(CameraProperties::SUPPORTED_EV_MAX));
2980    p.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION, mCameraProperties->get(CameraProperties::SUPPORTED_EV_MIN));
2981    p.set(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP, mCameraProperties->get(CameraProperties::SUPPORTED_EV_STEP));
2982    p.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES, mCameraProperties->get(CameraProperties::SUPPORTED_SCENE_MODES));
2983    p.set(TICameraParameters::KEY_SUPPORTED_EXPOSURE, mCameraProperties->get(CameraProperties::SUPPORTED_EXPOSURE_MODES));
2984    p.set(TICameraParameters::KEY_SUPPORTED_ISO_VALUES, mCameraProperties->get(CameraProperties::SUPPORTED_ISO_VALUES));
2985    p.set(CameraParameters::KEY_ZOOM_RATIOS, mCameraProperties->get(CameraProperties::SUPPORTED_ZOOM_RATIOS));
2986    p.set(CameraParameters::KEY_MAX_ZOOM, mCameraProperties->get(CameraProperties::SUPPORTED_ZOOM_STAGES));
2987    p.set(CameraParameters::KEY_ZOOM_SUPPORTED, mCameraProperties->get(CameraProperties::ZOOM_SUPPORTED));
2988    p.set(CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED, mCameraProperties->get(CameraProperties::SMOOTH_ZOOM_SUPPORTED));
2989    p.set(TICameraParameters::KEY_SUPPORTED_IPP, mCameraProperties->get(CameraProperties::SUPPORTED_IPP_MODES));
2990    p.set(TICameraParameters::KEY_S3D_SUPPORTED,mCameraProperties->get(CameraProperties::S3D_SUPPORTED));
2991    p.set(TICameraParameters::KEY_S3D2D_PREVIEW_MODE,mCameraProperties->get(CameraProperties::S3D2D_PREVIEW_MODES));
2992    p.set(TICameraParameters::KEY_AUTOCONVERGENCE_MODE, mCameraProperties->get(CameraProperties::AUTOCONVERGENCE_MODE));
2993    p.set(TICameraParameters::KEY_MANUALCONVERGENCE_VALUES, mCameraProperties->get(CameraProperties::MANUALCONVERGENCE_VALUES));
2994    p.set(TICameraParameters::KEY_VSTAB,mCameraProperties->get(CameraProperties::VSTAB));
2995    p.set(TICameraParameters::KEY_VSTAB_VALUES,mCameraProperties->get(CameraProperties::VSTAB_VALUES));
2996    p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, mCameraProperties->get(CameraProperties::FRAMERATE_RANGE_SUPPORTED));
2997    p.set(TICameraParameters::KEY_SENSOR_ORIENTATION, mCameraProperties->get(CameraProperties::SENSOR_ORIENTATION));
2998    p.set(TICameraParameters::KEY_SENSOR_ORIENTATION_VALUES, mCameraProperties->get(CameraProperties::SENSOR_ORIENTATION_VALUES));
2999    p.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, mCameraProperties->get(CameraProperties::AUTO_EXPOSURE_LOCK_SUPPORTED));
3000    p.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, mCameraProperties->get(CameraProperties::AUTO_WHITEBALANCE_LOCK_SUPPORTED));
3001
3002    LOG_FUNCTION_NAME_EXIT;
3003
3004}
3005
3006void CameraHal::initDefaultParameters()
3007{
3008    //Purpose of this function is to initialize the default current and supported parameters for the currently
3009    //selected camera.
3010
3011    CameraParameters &p = mParameters;
3012    int currentRevision, adapterRevision;
3013    status_t ret = NO_ERROR;
3014    int width, height;
3015
3016    LOG_FUNCTION_NAME;
3017
3018    ret = parseResolution(mCameraProperties->get(CameraProperties::PREVIEW_SIZE), width, height);
3019
3020    if ( NO_ERROR == ret )
3021        {
3022        p.setPreviewSize(width, height);
3023        }
3024    else
3025        {
3026        p.setPreviewSize(MIN_WIDTH, MIN_HEIGHT);
3027        }
3028
3029    ret = parseResolution(mCameraProperties->get(CameraProperties::PICTURE_SIZE), width, height);
3030
3031    if ( NO_ERROR == ret )
3032        {
3033        p.setPictureSize(width, height);
3034        }
3035    else
3036        {
3037        p.setPictureSize(PICTURE_WIDTH, PICTURE_HEIGHT);
3038        }
3039
3040    ret = parseResolution(mCameraProperties->get(CameraProperties::JPEG_THUMBNAIL_SIZE), width, height);
3041
3042    if ( NO_ERROR == ret )
3043        {
3044        p.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, width);
3045        p.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, height);
3046        }
3047    else
3048        {
3049        p.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, MIN_WIDTH);
3050        p.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, MIN_HEIGHT);
3051        }
3052
3053    insertSupportedParams();
3054
3055    //Insert default values
3056    p.setPreviewFrameRate(atoi(mCameraProperties->get(CameraProperties::PREVIEW_FRAME_RATE)));
3057    p.setPreviewFormat(mCameraProperties->get(CameraProperties::PREVIEW_FORMAT));
3058    p.setPictureFormat(mCameraProperties->get(CameraProperties::PICTURE_FORMAT));
3059    p.set(CameraParameters::KEY_JPEG_QUALITY, mCameraProperties->get(CameraProperties::JPEG_QUALITY));
3060    p.set(CameraParameters::KEY_WHITE_BALANCE, mCameraProperties->get(CameraProperties::WHITEBALANCE));
3061    p.set(CameraParameters::KEY_EFFECT,  mCameraProperties->get(CameraProperties::EFFECT));
3062    p.set(CameraParameters::KEY_ANTIBANDING, mCameraProperties->get(CameraProperties::ANTIBANDING));
3063    p.set(CameraParameters::KEY_FLASH_MODE, mCameraProperties->get(CameraProperties::FLASH_MODE));
3064    p.set(CameraParameters::KEY_FOCUS_MODE, mCameraProperties->get(CameraProperties::FOCUS_MODE));
3065    p.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, mCameraProperties->get(CameraProperties::EV_COMPENSATION));
3066    p.set(CameraParameters::KEY_SCENE_MODE, mCameraProperties->get(CameraProperties::SCENE_MODE));
3067    p.set(CameraParameters::KEY_FLASH_MODE, mCameraProperties->get(CameraProperties::FLASH_MODE));
3068    p.set(CameraParameters::KEY_ZOOM, mCameraProperties->get(CameraProperties::ZOOM));
3069    p.set(TICameraParameters::KEY_CONTRAST, mCameraProperties->get(CameraProperties::CONTRAST));
3070    p.set(TICameraParameters::KEY_SATURATION, mCameraProperties->get(CameraProperties::SATURATION));
3071    p.set(TICameraParameters::KEY_BRIGHTNESS, mCameraProperties->get(CameraProperties::BRIGHTNESS));
3072    p.set(TICameraParameters::KEY_SHARPNESS, mCameraProperties->get(CameraProperties::SHARPNESS));
3073    p.set(TICameraParameters::KEY_EXPOSURE_MODE, mCameraProperties->get(CameraProperties::EXPOSURE_MODE));
3074    p.set(TICameraParameters::KEY_ISO, mCameraProperties->get(CameraProperties::ISO_MODE));
3075    p.set(TICameraParameters::KEY_IPP, mCameraProperties->get(CameraProperties::IPP));
3076    p.set(TICameraParameters::KEY_S3D2D_PREVIEW, mCameraProperties->get(CameraProperties::S3D2D_PREVIEW));
3077    p.set(TICameraParameters::KEY_AUTOCONVERGENCE, mCameraProperties->get(CameraProperties::AUTOCONVERGENCE));
3078    p.set(TICameraParameters::KEY_MANUALCONVERGENCE_VALUES, mCameraProperties->get(CameraProperties::MANUALCONVERGENCE_VALUES));
3079    p.set(TICameraParameters::KEY_VSTAB,mCameraProperties->get(CameraProperties::VSTAB));
3080    p.set(TICameraParameters::KEY_VSTAB_VALUES,mCameraProperties->get(CameraProperties::VSTAB_VALUES));
3081    p.set(CameraParameters::KEY_FOCAL_LENGTH, mCameraProperties->get(CameraProperties::FOCAL_LENGTH));
3082    p.set(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, mCameraProperties->get(CameraProperties::HOR_ANGLE));
3083    p.set(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, mCameraProperties->get(CameraProperties::VER_ANGLE));
3084    p.set(CameraParameters::KEY_PREVIEW_FPS_RANGE,mCameraProperties->get(CameraProperties::FRAMERATE_RANGE));
3085    p.set(TICameraParameters::KEY_SENSOR_ORIENTATION, mCameraProperties->get(CameraProperties::SENSOR_ORIENTATION));
3086    p.set(TICameraParameters::KEY_SENSOR_ORIENTATION_VALUES, mCameraProperties->get(CameraProperties::SENSOR_ORIENTATION_VALUES));
3087    p.set(TICameraParameters::KEY_EXIF_MAKE, mCameraProperties->get(CameraProperties::EXIF_MAKE));
3088    p.set(TICameraParameters::KEY_EXIF_MODEL, mCameraProperties->get(CameraProperties::EXIF_MODEL));
3089    p.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, mCameraProperties->get(CameraProperties::JPEG_THUMBNAIL_QUALITY));
3090    p.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT, "OMX_TI_COLOR_FormatYUV420PackedSemiPlanar");
3091    p.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW, mCameraProperties->get(CameraProperties::MAX_FD_HW_FACES));
3092    p.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW, mCameraProperties->get(CameraProperties::MAX_FD_SW_FACES));
3093
3094    // Only one area a.k.a Touch AF for now.
3095    // TODO: Add support for multiple focus areas.
3096    p.set(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS, mCameraProperties->get(CameraProperties::MAX_FOCUS_AREAS));
3097    p.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, mCameraProperties->get(CameraProperties::AUTO_EXPOSURE_LOCK));
3098    p.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, mCameraProperties->get(CameraProperties::AUTO_WHITEBALANCE_LOCK));
3099    p.set(CameraParameters::KEY_MAX_NUM_METERING_AREAS, mCameraProperties->get(CameraProperties::MAX_NUM_METERING_AREAS));
3100
3101    LOG_FUNCTION_NAME_EXIT;
3102}
3103
3104/**
3105   @brief Stop a previously started preview.
3106   @param none
3107   @return none
3108
3109 */
3110void CameraHal::forceStopPreview()
3111{
3112    LOG_FUNCTION_NAME;
3113
3114    // stop bracketing if it is running
3115    stopImageBracketing();
3116
3117    if(mDisplayAdapter.get() != NULL) {
3118        ///Stop the buffer display first
3119        mDisplayAdapter->disableDisplay();
3120    }
3121
3122    if(mAppCallbackNotifier.get() != NULL) {
3123        //Stop the callback sending
3124        mAppCallbackNotifier->stop();
3125        mAppCallbackNotifier->stopPreviewCallbacks();
3126    }
3127
3128    // since prerequisite for capturing is for camera system
3129    // to be previewing...cancel all captures before stopping
3130    // preview
3131    if ( mCameraAdapter->getState() == CameraAdapter::CAPTURE_STATE &&
3132         mCameraAdapter->getNextState() != CameraAdapter::PREVIEW_STATE) {
3133        mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_IMAGE_CAPTURE);
3134    }
3135
3136    if ( NULL != mCameraAdapter ) {
3137        cancelAutoFocus();
3138        //Stop the source of frames
3139        mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_PREVIEW);
3140    }
3141
3142    freePreviewBufs();
3143    freePreviewDataBufs();
3144
3145    mPreviewEnabled = false;
3146    mDisplayPaused = false;
3147
3148    LOG_FUNCTION_NAME_EXIT;
3149}
3150
3151/**
3152   @brief Deallocates memory for all the resources held by Camera HAL.
3153
3154   Frees the following objects- CameraAdapter, AppCallbackNotifier, DisplayAdapter,
3155   and Memory Manager
3156
3157   @param none
3158   @return none
3159
3160 */
3161void CameraHal::deinitialize()
3162{
3163    LOG_FUNCTION_NAME;
3164
3165    if ( mPreviewEnabled ) {
3166        forceStopPreview();
3167    }
3168
3169    freeImageBufs();
3170
3171    mSetPreviewWindowCalled = false;
3172
3173    if (mSensorListener.get()) {
3174        mSensorListener->disableSensor(SensorListener::SENSOR_ORIENTATION);
3175        mSensorListener.clear();
3176        mSensorListener = NULL;
3177    }
3178
3179    LOG_FUNCTION_NAME_EXIT;
3180
3181}
3182
3183status_t CameraHal::storeMetaDataInBuffers(bool enable)
3184{
3185    LOG_FUNCTION_NAME;
3186
3187    return mAppCallbackNotifier->useMetaDataBufferMode(enable);
3188
3189    LOG_FUNCTION_NAME_EXIT;
3190}
3191
3192};
3193
3194
3195