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