CameraHal.cpp revision 3dcde7b7332edf04cd597b01d69950544dcd6589 
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    {
2217    Mutex::Autolock lock(mLock);
2218    mMsgEnabled &= ~CAMERA_MSG_FOCUS;
2219    }
2220
2221    if( NULL != mCameraAdapter )
2222    {
2223        mCameraAdapter->sendCommand(CameraAdapter::CAMERA_CANCEL_AUTOFOCUS);
2224    }
2225    LOG_FUNCTION_NAME_EXIT;
2226    return NO_ERROR;
2227}
2228
2229void CameraHal::setEventProvider(int32_t eventMask, MessageNotifier * eventNotifier)
2230{
2231
2232    LOG_FUNCTION_NAME;
2233
2234    if ( NULL != mEventProvider )
2235        {
2236        mEventProvider->disableEventNotification(CameraHalEvent::ALL_EVENTS);
2237        delete mEventProvider;
2238        mEventProvider = NULL;
2239        }
2240
2241    mEventProvider = new EventProvider(eventNotifier, this, eventCallbackRelay);
2242    if ( NULL == mEventProvider )
2243        {
2244        CAMHAL_LOGEA("Error in creating EventProvider");
2245        }
2246    else
2247        {
2248        mEventProvider->enableEventNotification(eventMask);
2249        }
2250
2251    LOG_FUNCTION_NAME_EXIT;
2252}
2253
2254void CameraHal::eventCallbackRelay(CameraHalEvent* event)
2255{
2256    LOG_FUNCTION_NAME;
2257
2258    CameraHal *appcbn = ( CameraHal * ) (event->mCookie);
2259    appcbn->eventCallback(event );
2260
2261    LOG_FUNCTION_NAME_EXIT;
2262}
2263
2264void CameraHal::eventCallback(CameraHalEvent* event)
2265{
2266    LOG_FUNCTION_NAME;
2267
2268    if ( NULL != event )
2269        {
2270        switch( event->mEventType )
2271            {
2272            case CameraHalEvent::EVENT_FOCUS_LOCKED:
2273            case CameraHalEvent::EVENT_FOCUS_ERROR:
2274                {
2275                if ( mBracketingEnabled )
2276                    {
2277                    startImageBracketing();
2278                    }
2279                break;
2280                }
2281            default:
2282                {
2283                break;
2284                }
2285            };
2286        }
2287
2288    LOG_FUNCTION_NAME_EXIT;
2289}
2290
2291status_t CameraHal::startImageBracketing()
2292{
2293        status_t ret = NO_ERROR;
2294        CameraFrame frame;
2295        CameraAdapter::BuffersDescriptor desc;
2296
2297#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
2298
2299        gettimeofday(&mStartCapture, NULL);
2300
2301#endif
2302
2303        LOG_FUNCTION_NAME;
2304
2305        if(!previewEnabled() && !mDisplayPaused)
2306            {
2307            LOG_FUNCTION_NAME_EXIT;
2308            return NO_INIT;
2309            }
2310
2311        if ( !mBracketingEnabled )
2312            {
2313            return ret;
2314            }
2315
2316        if ( NO_ERROR == ret )
2317            {
2318            mBracketingRunning = true;
2319            }
2320
2321        if (  (NO_ERROR == ret) && ( NULL != mCameraAdapter ) )
2322            {
2323            ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE,
2324                                              ( int ) &frame,
2325                                              ( mBracketRangeNegative + 1 ));
2326
2327            if ( NO_ERROR != ret )
2328                {
2329                CAMHAL_LOGEB("CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE returned error 0x%x", ret);
2330                }
2331            }
2332
2333        if ( NO_ERROR == ret )
2334            {
2335            if ( NULL != mAppCallbackNotifier.get() )
2336                 {
2337                 mAppCallbackNotifier->setBurst(true);
2338                 }
2339            }
2340
2341        if ( NO_ERROR == ret )
2342            {
2343            mParameters.getPictureSize(( int * ) &frame.mWidth,
2344                                       ( int * ) &frame.mHeight);
2345
2346            ret = allocImageBufs(frame.mWidth,
2347                                 frame.mHeight,
2348                                 frame.mLength,
2349                                 mParameters.getPictureFormat(),
2350                                 ( mBracketRangeNegative + 1 ));
2351            if ( NO_ERROR != ret )
2352              {
2353                CAMHAL_LOGEB("allocImageBufs returned error 0x%x", ret);
2354              }
2355            }
2356
2357        if (  (NO_ERROR == ret) && ( NULL != mCameraAdapter ) )
2358            {
2359
2360            desc.mBuffers = mImageBufs;
2361            desc.mOffsets = mImageOffsets;
2362            desc.mFd = mImageFd;
2363            desc.mLength = mImageLength;
2364            desc.mCount = ( size_t ) ( mBracketRangeNegative + 1 );
2365            desc.mMaxQueueable = ( size_t ) ( mBracketRangeNegative + 1 );
2366
2367            ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_IMAGE_CAPTURE,
2368                                              ( int ) &desc);
2369
2370            if ( NO_ERROR == ret )
2371                {
2372
2373#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
2374
2375                 //pass capture timestamp along with the camera adapter command
2376                ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_BRACKET_CAPTURE,  ( mBracketRangePositive + 1 ),  (int) &mStartCapture);
2377
2378#else
2379
2380                ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_BRACKET_CAPTURE, ( mBracketRangePositive + 1 ));
2381
2382#endif
2383
2384                }
2385            }
2386
2387        return ret;
2388}
2389
2390status_t CameraHal::stopImageBracketing()
2391{
2392        status_t ret = NO_ERROR;
2393
2394        LOG_FUNCTION_NAME;
2395
2396        if( !previewEnabled() )
2397            {
2398            return NO_INIT;
2399            }
2400
2401        mBracketingRunning = false;
2402
2403        ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_BRACKET_CAPTURE);
2404
2405        LOG_FUNCTION_NAME_EXIT;
2406
2407        return ret;
2408}
2409
2410/**
2411   @brief Take a picture.
2412
2413   @param none
2414   @return NO_ERROR If able to switch to image capture
2415   @todo Define error codes if unable to switch to image capture
2416
2417 */
2418status_t CameraHal::takePicture( )
2419{
2420    status_t ret = NO_ERROR;
2421    CameraFrame frame;
2422    CameraAdapter::BuffersDescriptor desc;
2423    int burst;
2424    const char *valstr = NULL;
2425    unsigned int bufferCount = 1;
2426
2427    Mutex::Autolock lock(mLock);
2428
2429#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
2430
2431    gettimeofday(&mStartCapture, NULL);
2432
2433#endif
2434
2435    LOG_FUNCTION_NAME;
2436
2437    if(!previewEnabled() && !mDisplayPaused)
2438        {
2439        LOG_FUNCTION_NAME_EXIT;
2440        CAMHAL_LOGEA("Preview not started...");
2441        return NO_INIT;
2442        }
2443
2444    // return error if we are already capturing
2445    if ( (mCameraAdapter->getState() == CameraAdapter::CAPTURE_STATE &&
2446          mCameraAdapter->getNextState() != CameraAdapter::PREVIEW_STATE) ||
2447         (mCameraAdapter->getState() == CameraAdapter::VIDEO_CAPTURE_STATE &&
2448          mCameraAdapter->getNextState() != CameraAdapter::VIDEO_STATE) ) {
2449        CAMHAL_LOGEA("Already capturing an image...");
2450        return NO_INIT;
2451    }
2452
2453    // we only support video snapshot if we are in video mode (recording hint is set)
2454    valstr = mParameters.get(TICameraParameters::KEY_CAP_MODE);
2455    if ( (mCameraAdapter->getState() == CameraAdapter::VIDEO_STATE) &&
2456         (valstr && strcmp(valstr, TICameraParameters::VIDEO_MODE)) ) {
2457        CAMHAL_LOGEA("Trying to capture while recording without recording hint set...");
2458        return INVALID_OPERATION;
2459    }
2460
2461    if ( !mBracketingRunning )
2462        {
2463
2464         if ( NO_ERROR == ret )
2465            {
2466            burst = mParameters.getInt(TICameraParameters::KEY_BURST);
2467            }
2468
2469         //Allocate all buffers only in burst capture case
2470         if ( burst > 1 )
2471             {
2472             bufferCount = CameraHal::NO_BUFFERS_IMAGE_CAPTURE;
2473             if ( NULL != mAppCallbackNotifier.get() )
2474                 {
2475                 mAppCallbackNotifier->setBurst(true);
2476                 }
2477             }
2478         else
2479             {
2480             if ( NULL != mAppCallbackNotifier.get() )
2481                 {
2482                 mAppCallbackNotifier->setBurst(false);
2483                 }
2484             }
2485
2486        // pause preview during normal image capture
2487        // do not pause preview if recording (video state)
2488        if (NO_ERROR == ret &&
2489                NULL != mDisplayAdapter.get() &&
2490                burst < 1) {
2491            if (mCameraAdapter->getState() != CameraAdapter::VIDEO_STATE) {
2492                mDisplayPaused = true;
2493                mPreviewEnabled = false;
2494                ret = mDisplayAdapter->pauseDisplay(mDisplayPaused);
2495                // since preview is paused we should stop sending preview frames too
2496                if(mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME) {
2497                    mAppCallbackNotifier->disableMsgType (CAMERA_MSG_PREVIEW_FRAME);
2498                }
2499            }
2500
2501#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
2502            mDisplayAdapter->setSnapshotTimeRef(&mStartCapture);
2503#endif
2504        }
2505
2506        // if we taking video snapshot...
2507        if ((NO_ERROR == ret) && (mCameraAdapter->getState() == CameraAdapter::VIDEO_STATE)) {
2508            // enable post view frames if not already enabled so we can internally
2509            // save snapshot frames for generating thumbnail
2510            if((mMsgEnabled & CAMERA_MSG_POSTVIEW_FRAME) == 0) {
2511                mAppCallbackNotifier->enableMsgType(CAMERA_MSG_POSTVIEW_FRAME);
2512            }
2513        }
2514
2515        if ( (NO_ERROR == ret) && (NULL != mCameraAdapter) )
2516            {
2517            if ( NO_ERROR == ret )
2518                ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE,
2519                                                  ( int ) &frame,
2520                                                  bufferCount);
2521
2522            if ( NO_ERROR != ret )
2523                {
2524                CAMHAL_LOGEB("CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE returned error 0x%x", ret);
2525                }
2526            }
2527
2528        if ( NO_ERROR == ret )
2529            {
2530            mParameters.getPictureSize(( int * ) &frame.mWidth,
2531                                       ( int * ) &frame.mHeight);
2532
2533            ret = allocImageBufs(frame.mWidth,
2534                                 frame.mHeight,
2535                                 frame.mLength,
2536                                 mParameters.getPictureFormat(),
2537                                 bufferCount);
2538            if ( NO_ERROR != ret )
2539                {
2540                CAMHAL_LOGEB("allocImageBufs returned error 0x%x", ret);
2541                }
2542            }
2543
2544        if (  (NO_ERROR == ret) && ( NULL != mCameraAdapter ) )
2545            {
2546            desc.mBuffers = mImageBufs;
2547            desc.mOffsets = mImageOffsets;
2548            desc.mFd = mImageFd;
2549            desc.mLength = mImageLength;
2550            desc.mCount = ( size_t ) bufferCount;
2551            desc.mMaxQueueable = ( size_t ) bufferCount;
2552
2553            ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_IMAGE_CAPTURE,
2554                                              ( int ) &desc);
2555            }
2556        }
2557
2558    if ( ( NO_ERROR == ret ) && ( NULL != mCameraAdapter ) )
2559        {
2560
2561#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
2562
2563         //pass capture timestamp along with the camera adapter command
2564        ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_IMAGE_CAPTURE,  (int) &mStartCapture);
2565
2566#else
2567
2568        ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_IMAGE_CAPTURE);
2569
2570#endif
2571
2572        }
2573
2574    return ret;
2575}
2576
2577/**
2578   @brief Cancel a picture that was started with takePicture.
2579
2580   Calling this method when no picture is being taken is a no-op.
2581
2582   @param none
2583   @return NO_ERROR If cancel succeeded. Cancel can succeed if image callback is not sent
2584   @todo Define error codes
2585
2586 */
2587status_t CameraHal::cancelPicture( )
2588{
2589    LOG_FUNCTION_NAME;
2590
2591    Mutex::Autolock lock(mLock);
2592
2593    mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_IMAGE_CAPTURE);
2594
2595    return NO_ERROR;
2596}
2597
2598/**
2599   @brief Return the camera parameters.
2600
2601   @param none
2602   @return Currently configured camera parameters
2603
2604 */
2605char* CameraHal::getParameters()
2606{
2607    String8 params_str8;
2608    char* params_string;
2609    const char * valstr = NULL;
2610
2611    LOG_FUNCTION_NAME;
2612
2613    if( NULL != mCameraAdapter )
2614    {
2615        mCameraAdapter->getParameters(mParameters);
2616    }
2617
2618    CameraParameters mParams = mParameters;
2619
2620    // Handle RECORDING_HINT to Set/Reset Video Mode Parameters
2621    valstr = mParameters.get(CameraParameters::KEY_RECORDING_HINT);
2622    if(valstr != NULL)
2623      {
2624        if(strcmp(valstr, CameraParameters::TRUE) == 0)
2625          {
2626            //HACK FOR MMS MODE
2627            resetPreviewRes(&mParams, mVideoWidth, mVideoHeight);
2628          }
2629      }
2630
2631    // do not send internal parameters to upper layers
2632    mParams.remove(TICameraParameters::KEY_RECORDING_HINT);
2633
2634    params_str8 = mParams.flatten();
2635
2636    // camera service frees this string...
2637    params_string = (char*) malloc(sizeof(char) * (params_str8.length()+1));
2638    strcpy(params_string, params_str8.string());
2639
2640    LOG_FUNCTION_NAME_EXIT;
2641
2642    ///Return the current set of parameters
2643
2644    return params_string;
2645}
2646
2647void CameraHal::putParameters(char *parms)
2648{
2649    free(parms);
2650}
2651
2652/**
2653   @brief Send command to camera driver.
2654
2655   @param none
2656   @return NO_ERROR If the command succeeds
2657   @todo Define the error codes that this function can return
2658
2659 */
2660status_t CameraHal::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2)
2661{
2662    status_t ret = NO_ERROR;
2663
2664    LOG_FUNCTION_NAME;
2665
2666
2667    if ( ( NO_ERROR == ret ) && ( NULL == mCameraAdapter ) )
2668        {
2669        CAMHAL_LOGEA("No CameraAdapter instance");
2670        ret = -EINVAL;
2671        }
2672
2673    if ( ( NO_ERROR == ret ) && ( !previewEnabled() ))
2674        {
2675        CAMHAL_LOGEA("Preview is not running");
2676        ret = -EINVAL;
2677        }
2678
2679    if ( NO_ERROR == ret )
2680        {
2681        switch(cmd)
2682            {
2683            case CAMERA_CMD_START_SMOOTH_ZOOM:
2684
2685                ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_SMOOTH_ZOOM, arg1);
2686
2687                break;
2688            case CAMERA_CMD_STOP_SMOOTH_ZOOM:
2689
2690                ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_SMOOTH_ZOOM);
2691
2692            case CAMERA_CMD_START_FACE_DETECTION:
2693
2694                ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_FD);
2695
2696                break;
2697
2698            case CAMERA_CMD_STOP_FACE_DETECTION:
2699
2700                ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_FD);
2701
2702                break;
2703
2704            default:
2705                break;
2706            };
2707        }
2708
2709    LOG_FUNCTION_NAME_EXIT;
2710
2711    return ret;
2712}
2713
2714/**
2715   @brief Release the hardware resources owned by this object.
2716
2717   Note that this is *not* done in the destructor.
2718
2719   @param none
2720   @return none
2721
2722 */
2723void CameraHal::release()
2724{
2725    LOG_FUNCTION_NAME;
2726    ///@todo Investigate on how release is used by CameraService. Vaguely remember that this is called
2727    ///just before CameraHal object destruction
2728    deinitialize();
2729    LOG_FUNCTION_NAME_EXIT;
2730}
2731
2732
2733/**
2734   @brief Dump state of the camera hardware
2735
2736   @param[in] fd    File descriptor
2737   @param[in] args  Arguments
2738   @return NO_ERROR Dump succeeded
2739   @todo  Error codes for dump fail
2740
2741 */
2742status_t  CameraHal::dump(int fd) const
2743{
2744    LOG_FUNCTION_NAME;
2745    ///Implement this method when the h/w dump function is supported on Ducati side
2746    return NO_ERROR;
2747}
2748
2749/*-------------Camera Hal Interface Method definitions ENDS here--------------------*/
2750
2751
2752
2753
2754/*-------------Camera Hal Internal Method definitions STARTS here--------------------*/
2755
2756/**
2757   @brief Constructor of CameraHal
2758
2759   Member variables are initialized here.  No allocations should be done here as we
2760   don't use c++ exceptions in the code.
2761
2762 */
2763CameraHal::CameraHal(int cameraId)
2764{
2765    LOG_FUNCTION_NAME;
2766
2767    ///Initialize all the member variables to their defaults
2768    mPreviewEnabled = false;
2769    mPreviewBufs = NULL;
2770    mImageBufs = NULL;
2771    mBufProvider = NULL;
2772    mPreviewStartInProgress = false;
2773    mVideoBufs = NULL;
2774    mVideoBufProvider = NULL;
2775    mRecordingEnabled = false;
2776    mDisplayPaused = false;
2777    mSetPreviewWindowCalled = false;
2778    mMsgEnabled = 0;
2779    mAppCallbackNotifier = NULL;
2780    mMemoryManager = NULL;
2781    mCameraAdapter = NULL;
2782    mBracketingEnabled = false;
2783    mBracketingRunning = false;
2784    mEventProvider = NULL;
2785    mBracketRangePositive = 1;
2786    mBracketRangeNegative = 1;
2787    mMaxZoomSupported = 0;
2788    mShutterEnabled = true;
2789    mMeasurementEnabled = false;
2790    mPreviewDataBufs = NULL;
2791    mCameraProperties = NULL;
2792    mCurrentTime = 0;
2793    mFalsePreview = 0;
2794    mImageOffsets = NULL;
2795    mImageLength = 0;
2796    mImageFd = 0;
2797    mVideoOffsets = NULL;
2798    mVideoFd = 0;
2799    mVideoLength = 0;
2800    mPreviewDataOffsets = NULL;
2801    mPreviewDataFd = 0;
2802    mPreviewDataLength = 0;
2803    mPreviewFd = 0;
2804    mPreviewWidth = 0;
2805    mPreviewHeight = 0;
2806    mPreviewLength = 0;
2807    mPreviewOffsets = NULL;
2808    mPreviewRunning = 0;
2809    mPreviewStateOld = 0;
2810    mRecordingEnabled = 0;
2811    mRecordEnabled = 0;
2812    mSensorListener = NULL;
2813    mVideoWidth = 0;
2814    mVideoHeight = 0;
2815
2816#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
2817
2818    //Initialize the CameraHAL constructor timestamp, which is used in the
2819    // PPM() method as time reference if the user does not supply one.
2820    gettimeofday(&ppm_start, NULL);
2821
2822#endif
2823
2824    mCameraIndex = cameraId;
2825
2826    LOG_FUNCTION_NAME_EXIT;
2827}
2828
2829/**
2830   @brief Destructor of CameraHal
2831
2832   This function simply calls deinitialize() to free up memory allocate during construct
2833   phase
2834 */
2835CameraHal::~CameraHal()
2836{
2837    LOG_FUNCTION_NAME;
2838
2839    ///Call de-initialize here once more - it is the last chance for us to relinquish all the h/w and s/w resources
2840    deinitialize();
2841
2842    if ( NULL != mEventProvider )
2843        {
2844        mEventProvider->disableEventNotification(CameraHalEvent::ALL_EVENTS);
2845        delete mEventProvider;
2846        mEventProvider = NULL;
2847        }
2848
2849    /// Free the callback notifier
2850    mAppCallbackNotifier.clear();
2851
2852    /// Free the display adapter
2853    mDisplayAdapter.clear();
2854
2855    if ( NULL != mCameraAdapter ) {
2856        int strongCount = mCameraAdapter->getStrongCount();
2857
2858        mCameraAdapter->decStrong(mCameraAdapter);
2859
2860        mCameraAdapter = NULL;
2861    }
2862
2863    freeImageBufs();
2864
2865    /// Free the memory manager
2866    mMemoryManager.clear();
2867
2868    LOG_FUNCTION_NAME_EXIT;
2869}
2870
2871/**
2872   @brief Initialize the Camera HAL
2873
2874   Creates CameraAdapter, AppCallbackNotifier, DisplayAdapter and MemoryManager
2875
2876   @param None
2877   @return NO_ERROR - On success
2878         NO_MEMORY - On failure to allocate memory for any of the objects
2879   @remarks Camera Hal internal function
2880
2881 */
2882
2883status_t CameraHal::initialize(CameraProperties::Properties* properties)
2884{
2885    LOG_FUNCTION_NAME;
2886
2887    int sensor_index = 0;
2888
2889    ///Initialize the event mask used for registering an event provider for AppCallbackNotifier
2890    ///Currently, registering all events as to be coming from CameraAdapter
2891    int32_t eventMask = CameraHalEvent::ALL_EVENTS;
2892
2893    // Get my camera properties
2894    mCameraProperties = properties;
2895
2896    if(!mCameraProperties)
2897    {
2898        goto fail_loop;
2899    }
2900
2901    // Dump the properties of this Camera
2902    // will only print if DEBUG macro is defined
2903    mCameraProperties->dump();
2904
2905    if (strcmp(CameraProperties::DEFAULT_VALUE, mCameraProperties->get(CameraProperties::CAMERA_SENSOR_INDEX)) != 0 )
2906        {
2907        sensor_index = atoi(mCameraProperties->get(CameraProperties::CAMERA_SENSOR_INDEX));
2908        }
2909
2910    CAMHAL_LOGDB("Sensor index %d", sensor_index);
2911
2912    mCameraAdapter = CameraAdapter_Factory(sensor_index);
2913    if ( ( NULL == mCameraAdapter ) || (mCameraAdapter->initialize(properties)!=NO_ERROR))
2914        {
2915        CAMHAL_LOGEA("Unable to create or initialize CameraAdapter");
2916        mCameraAdapter = NULL;
2917        goto fail_loop;
2918        }
2919
2920    mCameraAdapter->incStrong(mCameraAdapter);
2921    mCameraAdapter->registerImageReleaseCallback(releaseImageBuffers, (void *) this);
2922    mCameraAdapter->registerEndCaptureCallback(endImageCapture, (void *)this);
2923
2924    if(!mAppCallbackNotifier.get())
2925        {
2926        /// Create the callback notifier
2927        mAppCallbackNotifier = new AppCallbackNotifier();
2928        if( ( NULL == mAppCallbackNotifier.get() ) || ( mAppCallbackNotifier->initialize() != NO_ERROR))
2929            {
2930            CAMHAL_LOGEA("Unable to create or initialize AppCallbackNotifier");
2931            goto fail_loop;
2932            }
2933        }
2934
2935    if(!mMemoryManager.get())
2936        {
2937        /// Create Memory Manager
2938        mMemoryManager = new MemoryManager();
2939        if( ( NULL == mMemoryManager.get() ) || ( mMemoryManager->initialize() != NO_ERROR))
2940            {
2941            CAMHAL_LOGEA("Unable to create or initialize MemoryManager");
2942            goto fail_loop;
2943            }
2944        }
2945
2946    ///Setup the class dependencies...
2947
2948    ///AppCallbackNotifier has to know where to get the Camera frames and the events like auto focus lock etc from.
2949    ///CameraAdapter is the one which provides those events
2950    ///Set it as the frame and event providers for AppCallbackNotifier
2951    ///@remarks  setEventProvider API takes in a bit mask of events for registering a provider for the different events
2952    ///         That way, if events can come from DisplayAdapter in future, we will be able to add it as provider
2953    ///         for any event
2954    mAppCallbackNotifier->setEventProvider(eventMask, mCameraAdapter);
2955    mAppCallbackNotifier->setFrameProvider(mCameraAdapter);
2956
2957    ///Any dynamic errors that happen during the camera use case has to be propagated back to the application
2958    ///via CAMERA_MSG_ERROR. AppCallbackNotifier is the class that  notifies such errors to the application
2959    ///Set it as the error handler for CameraAdapter
2960    mCameraAdapter->setErrorHandler(mAppCallbackNotifier.get());
2961
2962    ///Start the callback notifier
2963    if(mAppCallbackNotifier->start() != NO_ERROR)
2964      {
2965        CAMHAL_LOGEA("Couldn't start AppCallbackNotifier");
2966        goto fail_loop;
2967      }
2968
2969    CAMHAL_LOGDA("Started AppCallbackNotifier..");
2970    mAppCallbackNotifier->setMeasurements(mMeasurementEnabled);
2971
2972    ///Initialize default parameters
2973    initDefaultParameters();
2974
2975
2976    if ( setParameters(mParameters) != NO_ERROR )
2977        {
2978        CAMHAL_LOGEA("Failed to set default parameters?!");
2979        }
2980
2981    // register for sensor events
2982    mSensorListener = new SensorListener();
2983    if (mSensorListener.get()) {
2984        if (mSensorListener->initialize() == NO_ERROR) {
2985            mSensorListener->setCallbacks(orientation_cb, this);
2986            mSensorListener->enableSensor(SensorListener::SENSOR_ORIENTATION);
2987        } else {
2988            CAMHAL_LOGEA("Error initializing SensorListener. not fatal, continuing");
2989            mSensorListener.clear();
2990            mSensorListener = NULL;
2991        }
2992    }
2993
2994    LOG_FUNCTION_NAME_EXIT;
2995
2996    return NO_ERROR;
2997
2998    fail_loop:
2999
3000        ///Free up the resources because we failed somewhere up
3001        deinitialize();
3002        LOG_FUNCTION_NAME_EXIT;
3003
3004        return NO_MEMORY;
3005
3006}
3007
3008bool CameraHal::isResolutionValid(unsigned int width, unsigned int height, const char *supportedResolutions)
3009{
3010    bool ret = true;
3011    status_t status = NO_ERROR;
3012    char tmpBuffer[PARAM_BUFFER + 1];
3013    char *pos = NULL;
3014
3015    LOG_FUNCTION_NAME;
3016
3017    if ( NULL == supportedResolutions )
3018        {
3019        CAMHAL_LOGEA("Invalid supported resolutions string");
3020        ret = false;
3021        goto exit;
3022        }
3023
3024    status = snprintf(tmpBuffer, PARAM_BUFFER, "%dx%d", width, height);
3025    if ( 0 > status )
3026        {
3027        CAMHAL_LOGEA("Error encountered while generating validation string");
3028        ret = false;
3029        goto exit;
3030        }
3031
3032    pos = strstr(supportedResolutions, tmpBuffer);
3033    if ( NULL == pos )
3034        {
3035        ret = false;
3036        }
3037    else
3038        {
3039        ret = true;
3040        }
3041
3042exit:
3043
3044    LOG_FUNCTION_NAME_EXIT;
3045
3046    return ret;
3047}
3048
3049bool CameraHal::isParameterValid(const char *param, const char *supportedParams)
3050{
3051    bool ret = true;
3052    char *pos = NULL;
3053
3054    LOG_FUNCTION_NAME;
3055
3056    if ( NULL == supportedParams )
3057        {
3058        CAMHAL_LOGEA("Invalid supported parameters string");
3059        ret = false;
3060        goto exit;
3061        }
3062
3063    if ( NULL == param )
3064        {
3065        CAMHAL_LOGEA("Invalid parameter string");
3066        ret = false;
3067        goto exit;
3068        }
3069
3070    pos = strstr(supportedParams, param);
3071    if ( NULL == pos )
3072        {
3073        ret = false;
3074        }
3075    else
3076        {
3077        ret = true;
3078        }
3079
3080exit:
3081
3082    LOG_FUNCTION_NAME_EXIT;
3083
3084    return ret;
3085}
3086
3087bool CameraHal::isParameterValid(int param, const char *supportedParams)
3088{
3089    bool ret = true;
3090    char *pos = NULL;
3091    status_t status;
3092    char tmpBuffer[PARAM_BUFFER + 1];
3093
3094    LOG_FUNCTION_NAME;
3095
3096    if ( NULL == supportedParams )
3097        {
3098        CAMHAL_LOGEA("Invalid supported parameters string");
3099        ret = false;
3100        goto exit;
3101        }
3102
3103    status = snprintf(tmpBuffer, PARAM_BUFFER, "%d", param);
3104    if ( 0 > status )
3105        {
3106        CAMHAL_LOGEA("Error encountered while generating validation string");
3107        ret = false;
3108        goto exit;
3109        }
3110
3111    pos = strstr(supportedParams, tmpBuffer);
3112    if ( NULL == pos )
3113        {
3114        ret = false;
3115        }
3116    else
3117        {
3118        ret = true;
3119        }
3120
3121exit:
3122
3123    LOG_FUNCTION_NAME_EXIT;
3124
3125    return ret;
3126}
3127
3128status_t CameraHal::doesSetParameterNeedUpdate(const char* new_param, const char* old_param, bool& update) {
3129    if (!new_param || !old_param) {
3130        return -EINVAL;
3131    }
3132
3133    // if params mismatch we should update parameters for camera adapter
3134    if ((strcmp(new_param, old_param) != 0)) {
3135       update = true;
3136    }
3137
3138   return NO_ERROR;
3139}
3140
3141status_t CameraHal::parseResolution(const char *resStr, int &width, int &height)
3142{
3143    status_t ret = NO_ERROR;
3144    char *ctx, *pWidth, *pHeight;
3145    const char *sep = "x";
3146    char *tmp = NULL;
3147
3148    LOG_FUNCTION_NAME;
3149
3150    if ( NULL == resStr )
3151        {
3152        return -EINVAL;
3153        }
3154
3155    //This fixes "Invalid input resolution"
3156    char *resStr_copy = (char *)malloc(strlen(resStr) + 1);
3157    if ( NULL!=resStr_copy ) {
3158    if ( NO_ERROR == ret )
3159        {
3160        strcpy(resStr_copy, resStr);
3161        pWidth = strtok_r( (char *) resStr_copy, sep, &ctx);
3162
3163        if ( NULL != pWidth )
3164            {
3165            width = atoi(pWidth);
3166            }
3167        else
3168            {
3169            CAMHAL_LOGEB("Invalid input resolution %s", resStr);
3170            ret = -EINVAL;
3171            }
3172        }
3173
3174    if ( NO_ERROR == ret )
3175        {
3176        pHeight = strtok_r(NULL, sep, &ctx);
3177
3178        if ( NULL != pHeight )
3179            {
3180            height = atoi(pHeight);
3181            }
3182        else
3183            {
3184            CAMHAL_LOGEB("Invalid input resolution %s", resStr);
3185            ret = -EINVAL;
3186            }
3187        }
3188
3189        free(resStr_copy);
3190        resStr_copy = NULL;
3191     }
3192    LOG_FUNCTION_NAME_EXIT;
3193
3194    return ret;
3195}
3196
3197void CameraHal::insertSupportedParams()
3198{
3199    char tmpBuffer[PARAM_BUFFER + 1];
3200
3201    LOG_FUNCTION_NAME;
3202
3203    CameraParameters &p = mParameters;
3204
3205    ///Set the name of the camera
3206    p.set(TICameraParameters::KEY_CAMERA_NAME, mCameraProperties->get(CameraProperties::CAMERA_NAME));
3207
3208    mMaxZoomSupported = atoi(mCameraProperties->get(CameraProperties::SUPPORTED_ZOOM_STAGES));
3209
3210    p.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_SIZES));
3211    p.set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_FORMATS));
3212    p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_SIZES));
3213    p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FORMATS));
3214    p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FRAME_RATES));
3215    p.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_THUMBNAIL_SIZES));
3216    p.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE, mCameraProperties->get(CameraProperties::SUPPORTED_WHITE_BALANCE));
3217    p.set(CameraParameters::KEY_SUPPORTED_EFFECTS, mCameraProperties->get(CameraProperties::SUPPORTED_EFFECTS));
3218    p.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES, mCameraProperties->get(CameraProperties::SUPPORTED_SCENE_MODES));
3219    p.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, mCameraProperties->get(CameraProperties::SUPPORTED_FLASH_MODES));
3220    p.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES, mCameraProperties->get(CameraProperties::SUPPORTED_FOCUS_MODES));
3221    p.set(CameraParameters::KEY_SUPPORTED_ANTIBANDING, mCameraProperties->get(CameraProperties::SUPPORTED_ANTIBANDING));
3222    p.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION, mCameraProperties->get(CameraProperties::SUPPORTED_EV_MAX));
3223    p.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION, mCameraProperties->get(CameraProperties::SUPPORTED_EV_MIN));
3224    p.set(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP, mCameraProperties->get(CameraProperties::SUPPORTED_EV_STEP));
3225    p.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES, mCameraProperties->get(CameraProperties::SUPPORTED_SCENE_MODES));
3226    p.set(TICameraParameters::KEY_SUPPORTED_EXPOSURE, mCameraProperties->get(CameraProperties::SUPPORTED_EXPOSURE_MODES));
3227    p.set(TICameraParameters::KEY_SUPPORTED_ISO_VALUES, mCameraProperties->get(CameraProperties::SUPPORTED_ISO_VALUES));
3228    p.set(CameraParameters::KEY_ZOOM_RATIOS, mCameraProperties->get(CameraProperties::SUPPORTED_ZOOM_RATIOS));
3229    p.set(CameraParameters::KEY_MAX_ZOOM, mCameraProperties->get(CameraProperties::SUPPORTED_ZOOM_STAGES));
3230    p.set(CameraParameters::KEY_ZOOM_SUPPORTED, mCameraProperties->get(CameraProperties::ZOOM_SUPPORTED));
3231    p.set(CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED, mCameraProperties->get(CameraProperties::SMOOTH_ZOOM_SUPPORTED));
3232    p.set(TICameraParameters::KEY_SUPPORTED_IPP, mCameraProperties->get(CameraProperties::SUPPORTED_IPP_MODES));
3233    p.set(TICameraParameters::KEY_S3D_SUPPORTED,mCameraProperties->get(CameraProperties::S3D_SUPPORTED));
3234    p.set(TICameraParameters::KEY_S3D2D_PREVIEW_MODE,mCameraProperties->get(CameraProperties::S3D2D_PREVIEW_MODES));
3235    p.set(TICameraParameters::KEY_AUTOCONVERGENCE_MODE, mCameraProperties->get(CameraProperties::AUTOCONVERGENCE_MODE));
3236    p.set(TICameraParameters::KEY_MANUALCONVERGENCE_VALUES, mCameraProperties->get(CameraProperties::MANUALCONVERGENCE_VALUES));
3237    p.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED, mCameraProperties->get(CameraProperties::VSTAB_SUPPORTED));
3238    p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, mCameraProperties->get(CameraProperties::FRAMERATE_RANGE_SUPPORTED));
3239    p.set(TICameraParameters::KEY_SENSOR_ORIENTATION, mCameraProperties->get(CameraProperties::SENSOR_ORIENTATION));
3240    p.set(TICameraParameters::KEY_SENSOR_ORIENTATION_VALUES, mCameraProperties->get(CameraProperties::SENSOR_ORIENTATION_VALUES));
3241    p.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, mCameraProperties->get(CameraProperties::AUTO_EXPOSURE_LOCK_SUPPORTED));
3242    p.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, mCameraProperties->get(CameraProperties::AUTO_WHITEBALANCE_LOCK_SUPPORTED));
3243    p.set(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED, mCameraProperties->get(CameraProperties::VIDEO_SNAPSHOT_SUPPORTED));
3244
3245    LOG_FUNCTION_NAME_EXIT;
3246
3247}
3248
3249void CameraHal::initDefaultParameters()
3250{
3251    //Purpose of this function is to initialize the default current and supported parameters for the currently
3252    //selected camera.
3253
3254    CameraParameters &p = mParameters;
3255    int currentRevision, adapterRevision;
3256    status_t ret = NO_ERROR;
3257    int width, height;
3258
3259    LOG_FUNCTION_NAME;
3260
3261    ret = parseResolution(mCameraProperties->get(CameraProperties::PREVIEW_SIZE), width, height);
3262
3263    if ( NO_ERROR == ret )
3264        {
3265        p.setPreviewSize(width, height);
3266        }
3267    else
3268        {
3269        p.setPreviewSize(MIN_WIDTH, MIN_HEIGHT);
3270        }
3271
3272    ret = parseResolution(mCameraProperties->get(CameraProperties::PICTURE_SIZE), width, height);
3273
3274    if ( NO_ERROR == ret )
3275        {
3276        p.setPictureSize(width, height);
3277        }
3278    else
3279        {
3280        p.setPictureSize(PICTURE_WIDTH, PICTURE_HEIGHT);
3281        }
3282
3283    ret = parseResolution(mCameraProperties->get(CameraProperties::JPEG_THUMBNAIL_SIZE), width, height);
3284
3285    if ( NO_ERROR == ret )
3286        {
3287        p.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, width);
3288        p.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, height);
3289        }
3290    else
3291        {
3292        p.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, MIN_WIDTH);
3293        p.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, MIN_HEIGHT);
3294        }
3295
3296    insertSupportedParams();
3297
3298    //Insert default values
3299    p.setPreviewFrameRate(atoi(mCameraProperties->get(CameraProperties::PREVIEW_FRAME_RATE)));
3300    p.setPreviewFormat(mCameraProperties->get(CameraProperties::PREVIEW_FORMAT));
3301    p.setPictureFormat(mCameraProperties->get(CameraProperties::PICTURE_FORMAT));
3302    p.set(CameraParameters::KEY_JPEG_QUALITY, mCameraProperties->get(CameraProperties::JPEG_QUALITY));
3303    p.set(CameraParameters::KEY_WHITE_BALANCE, mCameraProperties->get(CameraProperties::WHITEBALANCE));
3304    p.set(CameraParameters::KEY_EFFECT,  mCameraProperties->get(CameraProperties::EFFECT));
3305    p.set(CameraParameters::KEY_ANTIBANDING, mCameraProperties->get(CameraProperties::ANTIBANDING));
3306    p.set(CameraParameters::KEY_FLASH_MODE, mCameraProperties->get(CameraProperties::FLASH_MODE));
3307    p.set(CameraParameters::KEY_FOCUS_MODE, mCameraProperties->get(CameraProperties::FOCUS_MODE));
3308    p.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, mCameraProperties->get(CameraProperties::EV_COMPENSATION));
3309    p.set(CameraParameters::KEY_SCENE_MODE, mCameraProperties->get(CameraProperties::SCENE_MODE));
3310    p.set(CameraParameters::KEY_FLASH_MODE, mCameraProperties->get(CameraProperties::FLASH_MODE));
3311    p.set(CameraParameters::KEY_ZOOM, mCameraProperties->get(CameraProperties::ZOOM));
3312    p.set(TICameraParameters::KEY_CONTRAST, mCameraProperties->get(CameraProperties::CONTRAST));
3313    p.set(TICameraParameters::KEY_SATURATION, mCameraProperties->get(CameraProperties::SATURATION));
3314    p.set(TICameraParameters::KEY_BRIGHTNESS, mCameraProperties->get(CameraProperties::BRIGHTNESS));
3315    p.set(TICameraParameters::KEY_SHARPNESS, mCameraProperties->get(CameraProperties::SHARPNESS));
3316    p.set(TICameraParameters::KEY_EXPOSURE_MODE, mCameraProperties->get(CameraProperties::EXPOSURE_MODE));
3317    p.set(TICameraParameters::KEY_ISO, mCameraProperties->get(CameraProperties::ISO_MODE));
3318    p.set(TICameraParameters::KEY_IPP, mCameraProperties->get(CameraProperties::IPP));
3319    p.set(TICameraParameters::KEY_GBCE, mCameraProperties->get(CameraProperties::GBCE));
3320    p.set(TICameraParameters::KEY_S3D2D_PREVIEW, mCameraProperties->get(CameraProperties::S3D2D_PREVIEW));
3321    p.set(TICameraParameters::KEY_AUTOCONVERGENCE, mCameraProperties->get(CameraProperties::AUTOCONVERGENCE));
3322    p.set(TICameraParameters::KEY_MANUALCONVERGENCE_VALUES, mCameraProperties->get(CameraProperties::MANUALCONVERGENCE_VALUES));
3323    p.set(CameraParameters::KEY_VIDEO_STABILIZATION, mCameraProperties->get(CameraProperties::VSTAB));
3324    p.set(CameraParameters::KEY_FOCAL_LENGTH, mCameraProperties->get(CameraProperties::FOCAL_LENGTH));
3325    p.set(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, mCameraProperties->get(CameraProperties::HOR_ANGLE));
3326    p.set(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, mCameraProperties->get(CameraProperties::VER_ANGLE));
3327    p.set(CameraParameters::KEY_PREVIEW_FPS_RANGE,mCameraProperties->get(CameraProperties::FRAMERATE_RANGE));
3328    p.set(TICameraParameters::KEY_SENSOR_ORIENTATION, mCameraProperties->get(CameraProperties::SENSOR_ORIENTATION));
3329    p.set(TICameraParameters::KEY_SENSOR_ORIENTATION_VALUES, mCameraProperties->get(CameraProperties::SENSOR_ORIENTATION_VALUES));
3330    p.set(TICameraParameters::KEY_EXIF_MAKE, mCameraProperties->get(CameraProperties::EXIF_MAKE));
3331    p.set(TICameraParameters::KEY_EXIF_MODEL, mCameraProperties->get(CameraProperties::EXIF_MODEL));
3332    p.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, mCameraProperties->get(CameraProperties::JPEG_THUMBNAIL_QUALITY));
3333    p.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT, "OMX_TI_COLOR_FormatYUV420PackedSemiPlanar");
3334    p.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW, mCameraProperties->get(CameraProperties::MAX_FD_HW_FACES));
3335    p.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW, mCameraProperties->get(CameraProperties::MAX_FD_SW_FACES));
3336
3337    // Only one area a.k.a Touch AF for now.
3338    // TODO: Add support for multiple focus areas.
3339    p.set(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS, mCameraProperties->get(CameraProperties::MAX_FOCUS_AREAS));
3340    p.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, mCameraProperties->get(CameraProperties::AUTO_EXPOSURE_LOCK));
3341    p.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, mCameraProperties->get(CameraProperties::AUTO_WHITEBALANCE_LOCK));
3342    p.set(CameraParameters::KEY_MAX_NUM_METERING_AREAS, mCameraProperties->get(CameraProperties::MAX_NUM_METERING_AREAS));
3343
3344    LOG_FUNCTION_NAME_EXIT;
3345}
3346
3347/**
3348   @brief Stop a previously started preview.
3349   @param none
3350   @return none
3351
3352 */
3353void CameraHal::forceStopPreview()
3354{
3355    LOG_FUNCTION_NAME;
3356
3357    // stop bracketing if it is running
3358    stopImageBracketing();
3359
3360    if(mDisplayAdapter.get() != NULL) {
3361        ///Stop the buffer display first
3362        mDisplayAdapter->disableDisplay();
3363    }
3364
3365    if(mAppCallbackNotifier.get() != NULL) {
3366        //Stop the callback sending
3367        mAppCallbackNotifier->stop();
3368        mAppCallbackNotifier->flushAndReturnFrames();
3369        mAppCallbackNotifier->stopPreviewCallbacks();
3370    }
3371
3372    if ( NULL != mCameraAdapter ) {
3373        CameraAdapter::AdapterState currentState;
3374        CameraAdapter::AdapterState nextState;
3375
3376        currentState = mCameraAdapter->getState();
3377        nextState = mCameraAdapter->getNextState();
3378
3379        // since prerequisite for capturing is for camera system
3380        // to be previewing...cancel all captures before stopping
3381        // preview
3382        if ( (currentState == CameraAdapter::CAPTURE_STATE) &&
3383             (nextState != CameraAdapter::PREVIEW_STATE)) {
3384            mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_IMAGE_CAPTURE);
3385        }
3386
3387        // only need to send these control commands to state machine if we are
3388        // passed the LOADED_PREVIEW_STATE
3389        if (currentState > CameraAdapter::LOADED_PREVIEW_STATE) {
3390           // according to javadoc...FD should be stopped in stopPreview
3391           // and application needs to call startFaceDection again
3392           // to restart FD
3393           mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_FD);
3394           mCameraAdapter->sendCommand(CameraAdapter::CAMERA_CANCEL_AUTOFOCUS);
3395        }
3396
3397        // only need to send these control commands to state machine if we are
3398        // passed the INITIALIZED_STATE
3399        if (currentState > CameraAdapter::INTIALIZED_STATE) {
3400           //Stop the source of frames
3401           mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_PREVIEW);
3402        }
3403    }
3404
3405    freePreviewBufs();
3406    freePreviewDataBufs();
3407
3408    mPreviewEnabled = false;
3409    mDisplayPaused = false;
3410    mPreviewStartInProgress = false;
3411
3412    LOG_FUNCTION_NAME_EXIT;
3413}
3414
3415/**
3416   @brief Deallocates memory for all the resources held by Camera HAL.
3417
3418   Frees the following objects- CameraAdapter, AppCallbackNotifier, DisplayAdapter,
3419   and Memory Manager
3420
3421   @param none
3422   @return none
3423
3424 */
3425void CameraHal::deinitialize()
3426{
3427    LOG_FUNCTION_NAME;
3428
3429    if ( mPreviewEnabled || mDisplayPaused ) {
3430        forceStopPreview();
3431    }
3432
3433    mSetPreviewWindowCalled = false;
3434
3435    if (mSensorListener.get()) {
3436        mSensorListener->disableSensor(SensorListener::SENSOR_ORIENTATION);
3437        mSensorListener.clear();
3438        mSensorListener = NULL;
3439    }
3440
3441    LOG_FUNCTION_NAME_EXIT;
3442
3443}
3444
3445status_t CameraHal::storeMetaDataInBuffers(bool enable)
3446{
3447    LOG_FUNCTION_NAME;
3448
3449    return mAppCallbackNotifier->useMetaDataBufferMode(enable);
3450
3451    LOG_FUNCTION_NAME_EXIT;
3452}
3453
3454void CameraHal::selectFPSRange(int framerate, int *min_fps, int *max_fps)
3455{
3456  char * ptr;
3457  char supported[MAX_PROP_VALUE_LENGTH];
3458  int fpsrangeArray[2];
3459  int i = 0;
3460
3461  LOG_FUNCTION_NAME;
3462  size_t size = strlen(mCameraProperties->get(CameraProperties::FRAMERATE_RANGE_SUPPORTED))+1;
3463  strncpy(supported, mCameraProperties->get(CameraProperties::FRAMERATE_RANGE_SUPPORTED), size);
3464
3465  ptr = strtok (supported," (,)");
3466
3467  while (ptr != NULL)
3468    {
3469      fpsrangeArray[i]= atoi(ptr)/CameraHal::VFR_SCALE;
3470      if (i == 1)
3471        {
3472          if (framerate == fpsrangeArray[i])
3473            {
3474              CAMHAL_LOGDB("SETTING FPS RANGE min = %d max = %d \n", fpsrangeArray[0], fpsrangeArray[1]);
3475              *min_fps = fpsrangeArray[0]*CameraHal::VFR_SCALE;
3476              *max_fps = fpsrangeArray[1]*CameraHal::VFR_SCALE;
3477              break;
3478            }
3479        }
3480      ptr = strtok (NULL, " (,)");
3481      i++;
3482      i%=2;
3483    }
3484
3485  LOG_FUNCTION_NAME_EXIT;
3486
3487}
3488
3489void CameraHal::setPreferredPreviewRes(int width, int height)
3490{
3491  LOG_FUNCTION_NAME;
3492
3493  if ( (width == 320) && (height == 240)){
3494    mParameters.setPreviewSize(640,480);
3495  }
3496  if ( (width == 176) && (height == 144)){
3497    mParameters.setPreviewSize(704,576);
3498  }
3499
3500  LOG_FUNCTION_NAME_EXIT;
3501}
3502
3503void CameraHal::resetPreviewRes(CameraParameters *mParams, int width, int height)
3504{
3505  LOG_FUNCTION_NAME;
3506
3507  if ( (width <= 320) && (height <= 240)){
3508    mParams->setPreviewSize(mVideoWidth, mVideoHeight);
3509  }
3510
3511  LOG_FUNCTION_NAME_EXIT;
3512}
3513
3514};
3515
3516
3517