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