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