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