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