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