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