2
* Copyright (C) Texas Instruments - http://www.ti.com/
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
8
* http://www.apache.org/licenses/LICENSE-2.0
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.
20
* This file maps the Camera Hardware Interface to V4L2.
24
#define LOG_TAG "CameraHAL"
26
#include "CameraHal.h"
27
#include "ANativeWindowDisplayAdapter.h"
28
#include "TICameraParameters.h"
29
#include "CameraProperties.h"
30
#include <cutils/properties.h>
37
extern "C" CameraAdapter* CameraAdapter_Factory(size_t);
39
/*****************************************************************************/
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
45
const int CameraHal::NO_BUFFERS_PREVIEW = MAX_CAMERA_BUFFERS;
46
const int CameraHal::NO_BUFFERS_IMAGE_CAPTURE = 2;
48
const uint32_t MessageNotifier::EVENT_BIT_FIELD_POSITION = 0;
49
const uint32_t MessageNotifier::FRAME_BIT_FIELD_POSITION = 0;
51
/******************************************************************************/
53
#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
55
struct timeval CameraHal::mStartPreview;
56
struct timeval CameraHal::mStartFocus;
57
struct timeval CameraHal::mStartCapture;
61
static void orientation_cb(uint32_t orientation, uint32_t tilt, void* cookie) {
62
CameraHal *camera = NULL;
65
camera = (CameraHal*) cookie;
66
camera->onOrientationEvent(orientation, tilt);
70
/*-------------Camera Hal Interface Method definitions STARTS here--------------------*/
73
Callback function to receive orientation events from SensorListener
75
void CameraHal::onOrientationEvent(uint32_t orientation, uint32_t tilt) {
78
if ( NULL != mCameraAdapter ) {
79
mCameraAdapter->onOrientationEvent(orientation, tilt);
82
LOG_FUNCTION_NAME_EXIT;
86
@brief Set the notification and data callbacks
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
95
void 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,
103
if ( NULL != mAppCallbackNotifier.get() )
105
mAppCallbackNotifier->setCallbacks(this,
113
LOG_FUNCTION_NAME_EXIT;
117
@brief Enable a message, or set of messages.
119
@param[in] msgtype Bitmask of the messages to enable (defined in include/ui/Camera.h)
123
void CameraHal::enableMsgType(int32_t msgType)
127
if ( ( msgType & CAMERA_MSG_SHUTTER ) && ( !mShutterEnabled ) )
129
msgType &= ~CAMERA_MSG_SHUTTER;
132
// ignoring enable focus message from camera service
133
// we will enable internally in autoFocus call
134
msgType &= ~(CAMERA_MSG_FOCUS | CAMERA_MSG_FOCUS_MOVE);
137
Mutex::Autolock lock(mLock);
138
mMsgEnabled |= msgType;
141
if(mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME)
145
CAMHAL_LOGDA("Preview currently paused...will enable preview callback when restarted");
146
msgType &= ~CAMERA_MSG_PREVIEW_FRAME;
149
CAMHAL_LOGDA("Enabling Preview Callback");
154
CAMHAL_LOGDB("Preview callback not enabled %x", msgType);
158
///Configure app callback notifier with the message callback required
159
mAppCallbackNotifier->enableMsgType (msgType);
161
LOG_FUNCTION_NAME_EXIT;
165
@brief Disable a message, or set of messages.
167
@param[in] msgtype Bitmask of the messages to disable (defined in include/ui/Camera.h)
171
void CameraHal::disableMsgType(int32_t msgType)
176
Mutex::Autolock lock(mLock);
177
mMsgEnabled &= ~msgType;
180
if( msgType & CAMERA_MSG_PREVIEW_FRAME)
182
CAMHAL_LOGDA("Disabling Preview Callback");
185
///Configure app callback notifier
186
mAppCallbackNotifier->disableMsgType (msgType);
188
LOG_FUNCTION_NAME_EXIT;
192
@brief Query whether a message, or a set of messages, is enabled.
194
Note that this is operates as an AND, if any of the messages queried are off, this will
197
@param[in] msgtype Bitmask of the messages to query (defined in include/ui/Camera.h)
198
@return true If all message types are enabled
199
false If any message type
202
int CameraHal::msgTypeEnabled(int32_t msgType)
205
Mutex::Autolock lock(mLock);
206
LOG_FUNCTION_NAME_EXIT;
207
return (mMsgEnabled & msgType);
211
@brief Set the camera parameters.
213
@param[in] params Camera parameters to configure the camera
215
@todo Define error codes
218
int CameraHal::setParameters(const char* parameters)
223
CameraParameters params;
225
String8 str_params(parameters);
226
params.unflatten(str_params);
228
LOG_FUNCTION_NAME_EXIT;
230
return setParameters(params);
234
@brief Set the camera parameters.
236
@param[in] params Camera parameters to configure the camera
238
@todo Define error codes
241
int CameraHal::setParameters(const CameraParameters& params)
248
int framerate,minframerate;
250
const char *valstr = NULL;
252
status_t ret = NO_ERROR;
253
CameraParameters oldParams = mParameters;
254
// Needed for KEY_RECORDING_HINT
255
bool restartPreviewRequired = false;
256
bool updateRequired = false;
257
bool videoMode = false;
260
Mutex::Autolock lock(mLock);
262
///Ensure that preview is not enabled when the below parameters are changed.
263
if(!previewEnabled())
266
CAMHAL_LOGDB("PreviewFormat %s", params.getPreviewFormat());
268
if ((valstr = params.getPreviewFormat()) != NULL) {
269
if ( isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FORMATS))) {
270
mParameters.setPreviewFormat(valstr);
272
CAMHAL_LOGEB("Invalid preview format.Supported: %s", mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FORMATS));
277
varint = params.getInt(TICameraParameters::KEY_VNF);
278
valstr = params.get(TICameraParameters::KEY_VNF);
279
if ( valstr != NULL ) {
280
if ( ( varint == 0 ) || ( varint == 1 ) ) {
281
CAMHAL_LOGDB("VNF set %s", valstr);
282
mParameters.set(TICameraParameters::KEY_VNF, varint);
284
CAMHAL_LOGEB("ERROR: Invalid VNF: %s", valstr);
289
if ((valstr = params.get(CameraParameters::KEY_VIDEO_STABILIZATION)) != NULL) {
290
// make sure we support vstab...if we don't and application is trying to set
291
// vstab then return an error
292
if (strcmp(mCameraProperties->get(CameraProperties::VSTAB_SUPPORTED),
293
CameraParameters::TRUE) == 0) {
294
CAMHAL_LOGDB("VSTAB %s",valstr);
295
mParameters.set(CameraParameters::KEY_VIDEO_STABILIZATION, valstr);
296
} else if (strcmp(valstr, CameraParameters::TRUE) == 0) {
297
CAMHAL_LOGEB("ERROR: Invalid VSTAB: %s", valstr);
300
mParameters.set(CameraParameters::KEY_VIDEO_STABILIZATION,
301
CameraParameters::FALSE);
307
if( (valstr = params.get(TICameraParameters::KEY_CAP_MODE)) != NULL)
309
CAMHAL_LOGDB("Capture mode set %s", valstr);
310
mParameters.set(TICameraParameters::KEY_CAP_MODE, valstr);
313
if ((valstr = params.get(TICameraParameters::KEY_IPP)) != NULL) {
314
if (isParameterValid(valstr,mCameraProperties->get(CameraProperties::SUPPORTED_IPP_MODES))) {
315
CAMHAL_LOGDB("IPP mode set %s", valstr);
316
mParameters.set(TICameraParameters::KEY_IPP, valstr);
318
CAMHAL_LOGEB("ERROR: Invalid IPP mode: %s", valstr);
323
#ifdef OMAP_ENHANCEMENT
325
if((valstr = params.get(TICameraParameters::KEY_S3D2D_PREVIEW)) != NULL)
327
CAMHAL_LOGDB("Stereo 3D->2D Preview mode is %s", params.get(TICameraParameters::KEY_S3D2D_PREVIEW));
328
mParameters.set(TICameraParameters::KEY_S3D2D_PREVIEW, valstr);
331
if((valstr = params.get(TICameraParameters::KEY_AUTOCONVERGENCE)) != NULL)
333
CAMHAL_LOGDB("AutoConvergence mode is %s", params.get(TICameraParameters::KEY_AUTOCONVERGENCE));
334
mParameters.set(TICameraParameters::KEY_AUTOCONVERGENCE, valstr);
340
params.getPreviewSize(&w, &h);
341
if (w == -1 && h == -1) {
342
CAMHAL_LOGEA("Unable to get preview size");
346
int oldWidth, oldHeight;
347
mParameters.getPreviewSize(&oldWidth, &oldHeight);
349
#ifdef OMAP_ENHANCEMENT
352
if((valstr = params.get(TICameraParameters::KEY_SENSOR_ORIENTATION)) != NULL)
354
CAMHAL_LOGDB("Sensor Orientation is set to %s", params.get(TICameraParameters::KEY_SENSOR_ORIENTATION));
355
mParameters.set(TICameraParameters::KEY_SENSOR_ORIENTATION, valstr);
356
orientation = params.getInt(TICameraParameters::KEY_SENSOR_ORIENTATION);
359
if(orientation ==90 || orientation ==270)
361
if ( !isResolutionValid(h,w, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_SIZES)))
363
CAMHAL_LOGEB("Invalid preview resolution %d x %d", w, h);
368
mParameters.setPreviewSize(w, h);
375
if ( !isResolutionValid(w, h, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_SIZES)))
377
CAMHAL_LOGEB("Invalid preview resolution %d x %d", w, h);
382
mParameters.setPreviewSize(w, h);
389
if ( !isResolutionValid(w, h, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_SIZES))) {
390
CAMHAL_LOGEB("Invalid preview resolution %d x %d", w, h);
393
mParameters.setPreviewSize(w, h);
398
if ( ( oldWidth != w ) || ( oldHeight != h ) ) {
399
restartPreviewRequired |= true;
402
CAMHAL_LOGDB("PreviewResolution by App %d x %d", w, h);
404
// Handle RECORDING_HINT to Set/Reset Video Mode Parameters
405
valstr = params.get(CameraParameters::KEY_RECORDING_HINT);
408
if(strcmp(valstr, CameraParameters::TRUE) == 0)
410
CAMHAL_LOGDB("Recording Hint is set to %s", valstr);
411
mParameters.set(CameraParameters::KEY_RECORDING_HINT, valstr);
415
params.getPreviewSize(&w, &h);
416
CAMHAL_LOGVB("%s Preview Width=%d Height=%d\n", __FUNCTION__, w, h);
420
CAMHAL_LOGVB("%s Video Width=%d Height=%d\n", __FUNCTION__, mVideoWidth, mVideoHeight);
422
setPreferredPreviewRes(w, h);
423
mParameters.getPreviewSize(&w, &h);
424
CAMHAL_LOGVB("%s Preview Width=%d Height=%d\n", __FUNCTION__, w, h);
425
//Avoid restarting preview for MMS HACK
426
if ((w != mVideoWidth) && (h != mVideoHeight))
428
restartPreviewRequired = false;
431
restartPreviewRequired |= setVideoModeParameters(params);
433
else if(strcmp(valstr, CameraParameters::FALSE) == 0)
435
CAMHAL_LOGDB("Recording Hint is set to %s", valstr);
436
mParameters.set(CameraParameters::KEY_RECORDING_HINT, valstr);
437
restartPreviewRequired |= resetVideoModeParameters();
438
params.getPreviewSize(&mVideoWidth, &mVideoHeight);
442
CAMHAL_LOGEA("Invalid RECORDING_HINT");
448
// This check is required in following case.
449
// If VideoRecording activity sets KEY_RECORDING_HINT to TRUE and
450
// ImageCapture activity doesnot set KEY_RECORDING_HINT to FALSE (i.e. simply NULL),
451
// then Video Mode parameters may remain present in ImageCapture activity as well.
452
CAMHAL_LOGDA("Recording Hint is set to NULL");
453
mParameters.set(CameraParameters::KEY_RECORDING_HINT, "");
454
restartPreviewRequired |= resetVideoModeParameters();
455
params.getPreviewSize(&mVideoWidth, &mVideoHeight);
458
if ((valstr = params.get(CameraParameters::KEY_FOCUS_MODE)) != NULL) {
459
if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_FOCUS_MODES))) {
460
CAMHAL_LOGDB("Focus mode set %s", valstr);
462
// we need to take a decision on the capture mode based on whether CAF picture or
463
// video is chosen so the behavior of each is consistent to the application
464
if(strcmp(valstr, CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE) == 0){
465
restartPreviewRequired |= resetVideoModeParameters();
466
} else if (strcmp(valstr, CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO) == 0){
467
restartPreviewRequired |= setVideoModeParameters(params);
470
mParameters.set(CameraParameters::KEY_FOCUS_MODE, valstr);
472
CAMHAL_LOGEB("ERROR: Invalid FOCUS mode = %s", valstr);
477
///Below parameters can be changed when the preview is running
478
if ( (valstr = params.getPictureFormat()) != NULL ) {
479
if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_FORMATS))) {
480
mParameters.setPictureFormat(valstr);
482
CAMHAL_LOGEB("ERROR: Invalid picture format: %s",valstr);
487
params.getPictureSize(&w, &h);
488
if ( isResolutionValid(w, h, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_SIZES))) {
489
mParameters.setPictureSize(w, h);
491
CAMHAL_LOGEB("ERROR: Invalid picture resolution %dx%d", w, h);
495
CAMHAL_LOGDB("Picture Size by App %d x %d", w, h);
497
#ifdef OMAP_ENHANCEMENT
499
if ((valstr = params.get(TICameraParameters::KEY_BURST)) != NULL) {
500
if (params.getInt(TICameraParameters::KEY_BURST) >=0) {
501
CAMHAL_LOGDB("Burst set %s", valstr);
502
mParameters.set(TICameraParameters::KEY_BURST, valstr);
504
CAMHAL_LOGEB("ERROR: Invalid Burst value: %s",valstr);
511
framerate = params.getPreviewFrameRate();
512
valstr = params.get(CameraParameters::KEY_PREVIEW_FPS_RANGE);
513
CAMHAL_LOGDB("FRAMERATE %d", framerate);
515
CAMHAL_LOGVB("Passed FRR: %s, Supported FRR %s", valstr
516
, mCameraProperties->get(CameraProperties::FRAMERATE_RANGE_SUPPORTED));
517
CAMHAL_LOGVB("Passed FR: %d, Supported FR %s", framerate
518
, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FRAME_RATES));
521
//Perform parameter validation
522
if(!isParameterValid(valstr
523
, mCameraProperties->get(CameraProperties::FRAMERATE_RANGE_SUPPORTED))
524
|| !isParameterValid(framerate,
525
mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FRAME_RATES)))
527
CAMHAL_LOGEA("Invalid frame rate range or frame rate");
531
// Variable framerate ranges have higher priority over
532
// deprecated constant FPS. "KEY_PREVIEW_FPS_RANGE" should
533
// be cleared by the client in order for constant FPS to get
535
if ( strcmp(valstr, mCameraProperties->get(CameraProperties::FRAMERATE_RANGE)) != 0)
537
// APP wants to set FPS range
538
//Set framerate = MAXFPS
539
CAMHAL_LOGDA("APP IS CHANGING FRAME RATE RANGE");
540
params.getPreviewFpsRange(&minFPS, &maxFPS);
542
if ( ( 0 > minFPS ) || ( 0 > maxFPS ) )
544
CAMHAL_LOGEA("ERROR: FPS Range is negative!");
548
framerate = maxFPS /CameraHal::VFR_SCALE;
553
if ( framerate != atoi(mCameraProperties->get(CameraProperties::PREVIEW_FRAME_RATE)) )
556
selectFPSRange(framerate, &minFPS, &maxFPS);
557
CAMHAL_LOGDB("Select FPS Range %d %d", minFPS, maxFPS);
562
valstr = mCameraProperties->get(CameraProperties::FRAMERATE_RANGE_VIDEO);
563
CameraParameters temp;
564
temp.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, valstr);
565
temp.getPreviewFpsRange(&minFPS, &maxFPS);
568
valstr = mCameraProperties->get(CameraProperties::FRAMERATE_RANGE_IMAGE);
569
CameraParameters temp;
570
temp.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, valstr);
571
temp.getPreviewFpsRange(&minFPS, &maxFPS);
574
framerate = maxFPS / CameraHal::VFR_SCALE;
579
CAMHAL_LOGDB("FPS Range = %s", valstr);
580
CAMHAL_LOGDB("DEFAULT FPS Range = %s", mCameraProperties->get(CameraProperties::FRAMERATE_RANGE));
582
minFPS /= CameraHal::VFR_SCALE;
583
maxFPS /= CameraHal::VFR_SCALE;
585
if ( ( 0 == minFPS ) || ( 0 == maxFPS ) )
587
CAMHAL_LOGEA("ERROR: FPS Range is invalid!");
591
if ( maxFPS < minFPS )
593
CAMHAL_LOGEA("ERROR: Max FPS is smaller than Min FPS!");
596
CAMHAL_LOGDB("SET FRAMERATE %d", framerate);
597
mParameters.setPreviewFrameRate(framerate);
598
mParameters.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, params.get(CameraParameters::KEY_PREVIEW_FPS_RANGE));
600
CAMHAL_LOGDB("FPS Range [%d, %d]", minFPS, maxFPS);
601
mParameters.set(TICameraParameters::KEY_MINFRAMERATE, minFPS);
602
mParameters.set(TICameraParameters::KEY_MAXFRAMERATE, maxFPS);
604
if( ( valstr = params.get(TICameraParameters::KEY_GBCE) ) != NULL )
606
CAMHAL_LOGDB("GBCE Value = %s", valstr);
607
mParameters.set(TICameraParameters::KEY_GBCE, valstr);
610
if( ( valstr = params.get(TICameraParameters::KEY_GLBCE) ) != NULL )
612
CAMHAL_LOGDB("GLBCE Value = %s", valstr);
613
mParameters.set(TICameraParameters::KEY_GLBCE, valstr);
616
#ifdef OMAP_ENHANCEMENT
618
///Update the current parameter set
619
if( (valstr = params.get(TICameraParameters::KEY_AUTOCONVERGENCE)) != NULL)
621
CAMHAL_LOGDB("AutoConvergence Mode is set = %s", params.get(TICameraParameters::KEY_AUTOCONVERGENCE));
622
mParameters.set(TICameraParameters::KEY_AUTOCONVERGENCE, valstr);
625
if( (valstr = params.get(TICameraParameters::KEY_MANUALCONVERGENCE_VALUES)) !=NULL )
627
CAMHAL_LOGDB("ManualConvergence Value = %s", params.get(TICameraParameters::KEY_MANUALCONVERGENCE_VALUES));
628
mParameters.set(TICameraParameters::KEY_MANUALCONVERGENCE_VALUES, valstr);
631
if ((valstr = params.get(TICameraParameters::KEY_EXPOSURE_MODE)) != NULL) {
632
if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_EXPOSURE_MODES))) {
633
CAMHAL_LOGDB("Exposure set = %s", valstr);
634
mParameters.set(TICameraParameters::KEY_EXPOSURE_MODE, valstr);
636
CAMHAL_LOGEB("ERROR: Invalid Exposure = %s", valstr);
643
if ((valstr = params.get(CameraParameters::KEY_WHITE_BALANCE)) != NULL) {
644
if ( isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_WHITE_BALANCE))) {
645
CAMHAL_LOGDB("White balance set %s", valstr);
646
mParameters.set(CameraParameters::KEY_WHITE_BALANCE, valstr);
648
CAMHAL_LOGEB("ERROR: Invalid white balance = %s", valstr);
653
#ifdef OMAP_ENHANCEMENT
655
if ((valstr = params.get(TICameraParameters::KEY_CONTRAST)) != NULL) {
656
if (params.getInt(TICameraParameters::KEY_CONTRAST) >= 0 ) {
657
CAMHAL_LOGDB("Contrast set %s", valstr);
658
mParameters.set(TICameraParameters::KEY_CONTRAST, valstr);
660
CAMHAL_LOGEB("ERROR: Invalid Contrast = %s", valstr);
665
if ((valstr =params.get(TICameraParameters::KEY_SHARPNESS)) != NULL) {
666
if (params.getInt(TICameraParameters::KEY_SHARPNESS) >= 0 ) {
667
CAMHAL_LOGDB("Sharpness set %s", valstr);
668
mParameters.set(TICameraParameters::KEY_SHARPNESS, valstr);
670
CAMHAL_LOGEB("ERROR: Invalid Sharpness = %s", valstr);
675
if ((valstr = params.get(TICameraParameters::KEY_SATURATION)) != NULL) {
676
if (params.getInt(TICameraParameters::KEY_SATURATION) >= 0 ) {
677
CAMHAL_LOGDB("Saturation set %s", valstr);
678
mParameters.set(TICameraParameters::KEY_SATURATION, valstr);
680
CAMHAL_LOGEB("ERROR: Invalid Saturation = %s", valstr);
685
if ((valstr = params.get(TICameraParameters::KEY_BRIGHTNESS)) != NULL) {
686
if (params.getInt(TICameraParameters::KEY_BRIGHTNESS) >= 0 ) {
687
CAMHAL_LOGDB("Brightness set %s", valstr);
688
mParameters.set(TICameraParameters::KEY_BRIGHTNESS, valstr);
690
CAMHAL_LOGEB("ERROR: Invalid Brightness = %s", valstr);
697
if ((valstr = params.get(CameraParameters::KEY_ANTIBANDING)) != NULL) {
698
if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_ANTIBANDING))) {
699
CAMHAL_LOGDB("Antibanding set %s", valstr);
700
mParameters.set(CameraParameters::KEY_ANTIBANDING, valstr);
702
CAMHAL_LOGEB("ERROR: Invalid Antibanding = %s", valstr);
707
#ifdef OMAP_ENHANCEMENT
709
if ((valstr = params.get(TICameraParameters::KEY_ISO)) != NULL) {
710
if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_ISO_VALUES))) {
711
CAMHAL_LOGDB("ISO set %s", valstr);
712
mParameters.set(TICameraParameters::KEY_ISO, valstr);
714
CAMHAL_LOGEB("ERROR: Invalid ISO = %s", valstr);
721
if( (valstr = params.get(CameraParameters::KEY_FOCUS_AREAS)) != NULL )
723
CAMHAL_LOGDB("Focus areas position set %s",valstr);
724
mParameters.set(CameraParameters::KEY_FOCUS_AREAS, valstr);
727
#ifdef OMAP_ENHANCEMENT
729
if( (valstr = params.get(TICameraParameters::KEY_MEASUREMENT_ENABLE)) != NULL )
731
CAMHAL_LOGDB("Measurements set to %s", params.get(TICameraParameters::KEY_MEASUREMENT_ENABLE));
732
mParameters.set(TICameraParameters::KEY_MEASUREMENT_ENABLE, valstr);
734
if (strcmp(valstr, (const char *) TICameraParameters::MEASUREMENT_ENABLE) == 0)
736
mMeasurementEnabled = true;
738
else if (strcmp(valstr, (const char *) TICameraParameters::MEASUREMENT_DISABLE) == 0)
740
mMeasurementEnabled = false;
744
mMeasurementEnabled = false;
751
if( (valstr = params.get(CameraParameters::KEY_EXPOSURE_COMPENSATION)) != NULL)
753
CAMHAL_LOGDB("Exposure compensation set %s", valstr);
754
mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, valstr);
757
if ((valstr = params.get(CameraParameters::KEY_SCENE_MODE)) != NULL) {
758
if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_SCENE_MODES))) {
759
CAMHAL_LOGDB("Scene mode set %s", valstr);
760
doesSetParameterNeedUpdate(valstr,
761
mParameters.get(CameraParameters::KEY_SCENE_MODE),
763
mParameters.set(CameraParameters::KEY_SCENE_MODE, valstr);
765
CAMHAL_LOGEB("ERROR: Invalid Scene mode = %s", valstr);
770
if ((valstr = params.get(CameraParameters::KEY_FLASH_MODE)) != NULL) {
771
if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_FLASH_MODES))) {
772
CAMHAL_LOGDB("Flash mode set %s", valstr);
773
mParameters.set(CameraParameters::KEY_FLASH_MODE, valstr);
775
CAMHAL_LOGEB("ERROR: Invalid Flash mode = %s", valstr);
780
if ((valstr = params.get(CameraParameters::KEY_EFFECT)) != NULL) {
781
if (isParameterValid(valstr, mCameraProperties->get(CameraProperties::SUPPORTED_EFFECTS))) {
782
CAMHAL_LOGDB("Effect set %s", valstr);
783
mParameters.set(CameraParameters::KEY_EFFECT, valstr);
785
CAMHAL_LOGEB("ERROR: Invalid Effect = %s", valstr);
790
varint = params.getInt(CameraParameters::KEY_ROTATION);
793
CAMHAL_LOGDB("Rotation set %d", varint);
794
mParameters.set(CameraParameters::KEY_ROTATION, varint);
797
varint = params.getInt(CameraParameters::KEY_JPEG_QUALITY);
800
CAMHAL_LOGDB("Jpeg quality set %d", varint);
801
mParameters.set(CameraParameters::KEY_JPEG_QUALITY, varint);
804
varint = params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH);
807
CAMHAL_LOGDB("Thumbnail width set %d", varint);
808
mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, varint);
811
varint = params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);
814
CAMHAL_LOGDB("Thumbnail width set %d", varint);
815
mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, varint);
818
varint = params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY);
821
CAMHAL_LOGDB("Thumbnail quality set %d", varint);
822
mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, varint);
825
if( (valstr = params.get(CameraParameters::KEY_GPS_LATITUDE)) != NULL )
827
CAMHAL_LOGDB("GPS latitude set %s", valstr);
828
mParameters.set(CameraParameters::KEY_GPS_LATITUDE, valstr);
830
mParameters.remove(CameraParameters::KEY_GPS_LATITUDE);
833
if( (valstr = params.get(CameraParameters::KEY_GPS_LONGITUDE)) != NULL )
835
CAMHAL_LOGDB("GPS longitude set %s", valstr);
836
mParameters.set(CameraParameters::KEY_GPS_LONGITUDE, valstr);
838
mParameters.remove(CameraParameters::KEY_GPS_LONGITUDE);
841
if( (valstr = params.get(CameraParameters::KEY_GPS_ALTITUDE)) != NULL )
843
CAMHAL_LOGDB("GPS altitude set %s", valstr);
844
mParameters.set(CameraParameters::KEY_GPS_ALTITUDE, valstr);
846
mParameters.remove(CameraParameters::KEY_GPS_ALTITUDE);
849
if( (valstr = params.get(CameraParameters::KEY_GPS_TIMESTAMP)) != NULL )
851
CAMHAL_LOGDB("GPS timestamp set %s", valstr);
852
mParameters.set(CameraParameters::KEY_GPS_TIMESTAMP, valstr);
854
mParameters.remove(CameraParameters::KEY_GPS_TIMESTAMP);
857
if( (valstr = params.get(TICameraParameters::KEY_GPS_DATESTAMP)) != NULL )
859
CAMHAL_LOGDB("GPS datestamp set %s", valstr);
860
mParameters.set(TICameraParameters::KEY_GPS_DATESTAMP, valstr);
862
mParameters.remove(TICameraParameters::KEY_GPS_DATESTAMP);
865
if( (valstr = params.get(CameraParameters::KEY_GPS_PROCESSING_METHOD)) != NULL )
867
CAMHAL_LOGDB("GPS processing method set %s", valstr);
868
mParameters.set(CameraParameters::KEY_GPS_PROCESSING_METHOD, valstr);
870
mParameters.remove(CameraParameters::KEY_GPS_PROCESSING_METHOD);
873
if( (valstr = params.get(TICameraParameters::KEY_GPS_MAPDATUM )) != NULL )
875
CAMHAL_LOGDB("GPS MAPDATUM set %s", valstr);
876
mParameters.set(TICameraParameters::KEY_GPS_MAPDATUM, valstr);
878
mParameters.remove(TICameraParameters::KEY_GPS_MAPDATUM);
881
if( (valstr = params.get(TICameraParameters::KEY_GPS_VERSION)) != NULL )
883
CAMHAL_LOGDB("GPS MAPDATUM set %s", valstr);
884
mParameters.set(TICameraParameters::KEY_GPS_VERSION, valstr);
886
mParameters.remove(TICameraParameters::KEY_GPS_VERSION);
889
if( (valstr = params.get(TICameraParameters::KEY_EXIF_MODEL)) != NULL )
891
CAMHAL_LOGDB("EXIF Model set %s", valstr);
892
mParameters.set(TICameraParameters::KEY_EXIF_MODEL, valstr);
895
if( (valstr = params.get(TICameraParameters::KEY_EXIF_MAKE)) != NULL )
897
CAMHAL_LOGDB("EXIF Make set %s", valstr);
898
mParameters.set(TICameraParameters::KEY_EXIF_MAKE, valstr);
901
#ifdef OMAP_ENHANCEMENT
903
if( (valstr = params.get(TICameraParameters::KEY_EXP_BRACKETING_RANGE)) != NULL )
905
CAMHAL_LOGDB("Exposure Bracketing set %s", params.get(TICameraParameters::KEY_EXP_BRACKETING_RANGE));
906
mParameters.set(TICameraParameters::KEY_EXP_BRACKETING_RANGE, valstr);
910
mParameters.remove(TICameraParameters::KEY_EXP_BRACKETING_RANGE);
915
valstr = params.get(CameraParameters::KEY_ZOOM);
916
varint = params.getInt(CameraParameters::KEY_ZOOM);
917
if ( valstr != NULL ) {
918
if ( ( varint >= 0 ) && ( varint <= mMaxZoomSupported ) ) {
919
CAMHAL_LOGDB("Zoom set %s", valstr);
920
doesSetParameterNeedUpdate(valstr,
921
mParameters.get(CameraParameters::KEY_ZOOM),
923
mParameters.set(CameraParameters::KEY_ZOOM, valstr);
925
CAMHAL_LOGEB("ERROR: Invalid Zoom: %s", valstr);
930
if( (valstr = params.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK)) != NULL )
932
CAMHAL_LOGDB("Auto Exposure Lock set %s", valstr);
933
doesSetParameterNeedUpdate(valstr,
934
mParameters.get(CameraParameters::KEY_AUTO_EXPOSURE_LOCK),
936
mParameters.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, valstr);
939
if( (valstr = params.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK)) != NULL )
941
CAMHAL_LOGDB("Auto WhiteBalance Lock set %s", valstr);
942
doesSetParameterNeedUpdate(valstr,
943
mParameters.get(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK),
945
mParameters.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, valstr);
947
if( (valstr = params.get(CameraParameters::KEY_METERING_AREAS)) != NULL )
949
CAMHAL_LOGDB("Metering areas position set %s", valstr);
950
mParameters.set(CameraParameters::KEY_METERING_AREAS, valstr);
953
// Only send parameters to adapter if preview is already
954
// enabled or doesSetParameterNeedUpdate says so. Initial setParameters to camera adapter,
955
// will be called in startPreview()
956
// TODO(XXX): Need to identify other parameters that need update from camera adapter
957
if ( (NULL != mCameraAdapter) && (mPreviewEnabled || updateRequired) ) {
958
ret |= mCameraAdapter->setParameters(mParameters);
961
#ifdef OMAP_ENHANCEMENT
963
if( NULL != params.get(TICameraParameters::KEY_TEMP_BRACKETING_RANGE_POS) )
965
int posBracketRange = params.getInt(TICameraParameters::KEY_TEMP_BRACKETING_RANGE_POS);
966
if ( 0 < posBracketRange )
968
mBracketRangePositive = posBracketRange;
971
CAMHAL_LOGDB("Positive bracketing range %d", mBracketRangePositive);
974
if( NULL != params.get(TICameraParameters::KEY_TEMP_BRACKETING_RANGE_NEG) )
976
int negBracketRange = params.getInt(TICameraParameters::KEY_TEMP_BRACKETING_RANGE_NEG);
977
if ( 0 < negBracketRange )
979
mBracketRangeNegative = negBracketRange;
982
CAMHAL_LOGDB("Negative bracketing range %d", mBracketRangeNegative);
984
if( ( (valstr = params.get(TICameraParameters::KEY_TEMP_BRACKETING)) != NULL) &&
985
( strcmp(valstr, TICameraParameters::BRACKET_ENABLE) == 0 ))
987
if ( !mBracketingEnabled )
989
CAMHAL_LOGDA("Enabling bracketing");
990
mBracketingEnabled = true;
992
//Wait for AF events to enable bracketing
993
if ( NULL != mCameraAdapter )
995
setEventProvider( CameraHalEvent::ALL_EVENTS, mCameraAdapter );
1000
CAMHAL_LOGDA("Bracketing already enabled");
1003
else if ( ( (valstr = params.get(TICameraParameters::KEY_TEMP_BRACKETING)) != NULL ) &&
1004
( strcmp(valstr, TICameraParameters::BRACKET_DISABLE) == 0 ))
1006
CAMHAL_LOGDA("Disabling bracketing");
1008
mBracketingEnabled = false;
1009
stopImageBracketing();
1011
//Remove AF events subscription
1012
if ( NULL != mEventProvider )
1014
mEventProvider->disableEventNotification( CameraHalEvent::ALL_EVENTS );
1015
delete mEventProvider;
1016
mEventProvider = NULL;
1021
if( ( (valstr = params.get(TICameraParameters::KEY_SHUTTER_ENABLE)) != NULL ) &&
1022
( strcmp(valstr, TICameraParameters::SHUTTER_ENABLE) == 0 ))
1024
CAMHAL_LOGDA("Enabling shutter sound");
1026
mShutterEnabled = true;
1027
mMsgEnabled |= CAMERA_MSG_SHUTTER;
1028
mParameters.set(TICameraParameters::KEY_SHUTTER_ENABLE, valstr);
1030
else if ( ( (valstr = params.get(TICameraParameters::KEY_SHUTTER_ENABLE)) != NULL ) &&
1031
( strcmp(valstr, TICameraParameters::SHUTTER_DISABLE) == 0 ))
1033
CAMHAL_LOGDA("Disabling shutter sound");
1035
mShutterEnabled = false;
1036
mMsgEnabled &= ~CAMERA_MSG_SHUTTER;
1037
mParameters.set(TICameraParameters::KEY_SHUTTER_ENABLE, valstr);
1044
//On fail restore old parameters
1045
if ( NO_ERROR != ret ) {
1046
mParameters = oldParams;
1049
// Restart Preview if needed by KEY_RECODING_HINT only if preview is already running.
1050
// If preview is not started yet, Video Mode parameters will take effect on next startPreview()
1051
if (restartPreviewRequired && previewEnabled() && !mRecordingEnabled) {
1052
CAMHAL_LOGDA("Restarting Preview");
1053
ret = restartPreview();
1054
} else if (restartPreviewRequired && !previewEnabled() &&
1055
mDisplayPaused && !mRecordingEnabled) {
1056
CAMHAL_LOGDA("Stopping Preview");
1060
if (ret != NO_ERROR)
1062
CAMHAL_LOGEA("Failed to restart Preview");
1066
LOG_FUNCTION_NAME_EXIT;
1071
status_t CameraHal::allocPreviewBufs(int width, int height, const char* previewFormat,
1072
unsigned int buffercount, unsigned int &max_queueable)
1074
status_t ret = NO_ERROR;
1078
if(mDisplayAdapter.get() == NULL)
1080
// Memory allocation of preview buffers is now placed in gralloc
1081
// CameraHal should not allocate preview buffers without DisplayAdapter
1087
///@todo Pluralise the name of this method to allocateBuffers
1089
mPreviewBufs = (int32_t *) mDisplayAdapter->allocateBuffer(width, height,
1094
if (NULL == mPreviewBufs ) {
1095
CAMHAL_LOGEA("Couldn't allocate preview buffers");
1099
mPreviewOffsets = (uint32_t *) mDisplayAdapter->getOffsets();
1100
if ( NULL == mPreviewOffsets ) {
1101
CAMHAL_LOGEA("Buffer mapping failed");
1105
mPreviewFd = mDisplayAdapter->getFd();
1106
if ( -1 == mPreviewFd ) {
1107
CAMHAL_LOGEA("Invalid handle");
1111
mBufProvider = (BufferProvider*) mDisplayAdapter.get();
1113
ret = mDisplayAdapter->maxQueueableBuffers(max_queueable);
1114
if (ret != NO_ERROR) {
1120
LOG_FUNCTION_NAME_EXIT;
1126
status_t CameraHal::freePreviewBufs()
1128
status_t ret = NO_ERROR;
1131
CAMHAL_LOGDB("mPreviewBufs = 0x%x", (unsigned int)mPreviewBufs);
1134
///@todo Pluralise the name of this method to freeBuffers
1135
ret = mBufProvider->freeBuffer(mPreviewBufs);
1136
mPreviewBufs = NULL;
1137
LOG_FUNCTION_NAME_EXIT;
1140
LOG_FUNCTION_NAME_EXIT;
1145
status_t CameraHal::allocPreviewDataBufs(size_t size, size_t bufferCount)
1147
status_t ret = NO_ERROR;
1154
if ( NO_ERROR == ret )
1156
if( NULL != mPreviewDataBufs )
1158
ret = freePreviewDataBufs();
1162
if ( NO_ERROR == ret )
1164
bytes = ((bytes+4095)/4096)*4096;
1165
mPreviewDataBufs = (int32_t *)mMemoryManager->allocateBuffer(0, 0, NULL, bytes, bufferCount);
1167
CAMHAL_LOGDB("Size of Preview data buffer = %d", bytes);
1168
if( NULL == mPreviewDataBufs )
1170
CAMHAL_LOGEA("Couldn't allocate image buffers using memory manager");
1179
if ( NO_ERROR == ret )
1181
mPreviewDataFd = mMemoryManager->getFd();
1182
mPreviewDataLength = bytes;
1183
mPreviewDataOffsets = mMemoryManager->getOffsets();
1187
mPreviewDataFd = -1;
1188
mPreviewDataLength = 0;
1189
mPreviewDataOffsets = NULL;
1197
status_t CameraHal::freePreviewDataBufs()
1199
status_t ret = NO_ERROR;
1203
if ( NO_ERROR == ret )
1206
if( NULL != mPreviewDataBufs )
1209
///@todo Pluralise the name of this method to freeBuffers
1210
ret = mMemoryManager->freeBuffer(mPreviewDataBufs);
1211
mPreviewDataBufs = NULL;
1216
LOG_FUNCTION_NAME_EXIT;
1221
status_t CameraHal::allocImageBufs(unsigned int width, unsigned int height, size_t size, const char* previewFormat, unsigned int bufferCount)
1223
status_t ret = NO_ERROR;
1230
// allocate image buffers only if not already allocated
1231
if(NULL != mImageBufs) {
1235
if ( NO_ERROR == ret )
1237
bytes = ((bytes+4095)/4096)*4096;
1238
mImageBufs = (int32_t *)mMemoryManager->allocateBuffer(0, 0, previewFormat, bytes, bufferCount);
1240
CAMHAL_LOGDB("Size of Image cap buffer = %d", bytes);
1241
if( NULL == mImageBufs )
1243
CAMHAL_LOGEA("Couldn't allocate image buffers using memory manager");
1252
if ( NO_ERROR == ret )
1254
mImageFd = mMemoryManager->getFd();
1255
mImageLength = bytes;
1256
mImageOffsets = mMemoryManager->getOffsets();
1262
mImageOffsets = NULL;
1270
status_t CameraHal::allocVideoBufs(uint32_t width, uint32_t height, uint32_t bufferCount)
1272
status_t ret = NO_ERROR;
1275
if( NULL != mVideoBufs ){
1276
ret = freeVideoBufs(mVideoBufs);
1280
if ( NO_ERROR == ret ){
1282
buffer_handle_t *bufsArr = new buffer_handle_t [bufferCount];
1284
if (bufsArr != NULL){
1285
for (int i = 0; i< bufferCount; i++){
1286
GraphicBufferAllocator &GrallocAlloc = GraphicBufferAllocator::get();
1287
buffer_handle_t buf;
1288
ret = GrallocAlloc.alloc(width, height, HAL_PIXEL_FORMAT_NV12, CAMHAL_GRALLOC_USAGE, &buf, &stride);
1289
if (ret != NO_ERROR){
1290
CAMHAL_LOGEA("Couldn't allocate video buffers using Gralloc");
1292
for (int j=0; j< i; j++){
1293
buf = (buffer_handle_t)bufsArr[j];
1294
CAMHAL_LOGEB("Freeing Gralloc Buffer 0x%x", buf);
1295
GrallocAlloc.free(buf);
1301
CAMHAL_LOGVB("*** Gralloc Handle =0x%x ***", buf);
1304
mVideoBufs = (int32_t *)bufsArr;
1307
CAMHAL_LOGEA("Couldn't allocate video buffers ");
1318
void endImageCapture( void *userData)
1322
if ( NULL != userData )
1324
CameraHal *c = reinterpret_cast<CameraHal *>(userData);
1325
c->signalEndImageCapture();
1328
LOG_FUNCTION_NAME_EXIT;
1331
void releaseImageBuffers(void *userData)
1335
if (NULL != userData) {
1336
CameraHal *c = reinterpret_cast<CameraHal *>(userData);
1340
LOG_FUNCTION_NAME_EXIT;
1343
status_t CameraHal::signalEndImageCapture()
1345
status_t ret = NO_ERROR;
1347
CameraParameters adapterParams = mParameters;
1348
Mutex::Autolock lock(mLock);
1352
if ( mBracketingRunning ) {
1353
stopImageBracketing();
1355
mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_IMAGE_CAPTURE);
1358
LOG_FUNCTION_NAME_EXIT;
1363
status_t CameraHal::freeImageBufs()
1365
status_t ret = NO_ERROR;
1369
if ( NO_ERROR == ret )
1372
if( NULL != mImageBufs )
1375
///@todo Pluralise the name of this method to freeBuffers
1376
ret = mMemoryManager->freeBuffer(mImageBufs);
1387
LOG_FUNCTION_NAME_EXIT;
1392
status_t CameraHal::freeVideoBufs(void *bufs)
1394
status_t ret = NO_ERROR;
1398
buffer_handle_t *pBuf = (buffer_handle_t*)bufs;
1399
int count = atoi(mCameraProperties->get(CameraProperties::REQUIRED_PREVIEW_BUFS));
1402
CAMHAL_LOGEA("NULL pointer passed to freeVideoBuffer");
1403
LOG_FUNCTION_NAME_EXIT;
1407
GraphicBufferAllocator &GrallocAlloc = GraphicBufferAllocator::get();
1409
for(int i = 0; i < count; i++){
1410
buffer_handle_t ptr = *pBuf++;
1411
CAMHAL_LOGVB("Free Video Gralloc Handle 0x%x", ptr);
1412
GrallocAlloc.free(ptr);
1415
LOG_FUNCTION_NAME_EXIT;
1421
@brief Start preview mode.
1424
@return NO_ERROR Camera switched to VF mode
1425
@todo Update function header with the different errors that are possible
1428
status_t CameraHal::startPreview()
1431
status_t ret = NO_ERROR;
1432
CameraAdapter::BuffersDescriptor desc;
1434
const char *valstr = NULL;
1435
unsigned int required_buffer_count;
1436
unsigned int max_queueble_buffers;
1438
#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
1439
gettimeofday(&mStartPreview, NULL);
1444
if ( mPreviewEnabled ){
1445
CAMHAL_LOGDA("Preview already running");
1446
LOG_FUNCTION_NAME_EXIT;
1447
return ALREADY_EXISTS;
1450
if ( NULL != mCameraAdapter ) {
1451
ret = mCameraAdapter->setParameters(mParameters);
1454
if ((mPreviewStartInProgress == false) && (mDisplayPaused == false)){
1455
ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_RESOLUTION_PREVIEW,( int ) &frame);
1456
if ( NO_ERROR != ret ){
1457
CAMHAL_LOGEB("Error: CAMERA_QUERY_RESOLUTION_PREVIEW %d", ret);
1461
///Update the current preview width and height
1462
mPreviewWidth = frame.mWidth;
1463
mPreviewHeight = frame.mHeight;
1464
//Update the padded width and height - required for VNF and VSTAB
1465
mParameters.set(TICameraParameters::KEY_PADDED_WIDTH, mPreviewWidth);
1466
mParameters.set(TICameraParameters::KEY_PADDED_HEIGHT, mPreviewHeight);
1470
///If we don't have the preview callback enabled and display adapter,
1471
if(!mSetPreviewWindowCalled || (mDisplayAdapter.get() == NULL)){
1472
CAMHAL_LOGDA("Preview not started. Preview in progress flag set");
1473
mPreviewStartInProgress = true;
1474
ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_SWITCH_TO_EXECUTING);
1475
if ( NO_ERROR != ret ){
1476
CAMHAL_LOGEB("Error: CAMERA_SWITCH_TO_EXECUTING %d", ret);
1482
if( (mDisplayAdapter.get() != NULL) && ( !mPreviewEnabled ) && ( mDisplayPaused ) )
1484
CAMHAL_LOGDA("Preview is in paused state");
1486
mDisplayPaused = false;
1487
mPreviewEnabled = true;
1488
if ( NO_ERROR == ret )
1490
ret = mDisplayAdapter->pauseDisplay(mDisplayPaused);
1492
if ( NO_ERROR != ret )
1494
CAMHAL_LOGEB("Display adapter resume failed %x", ret);
1497
//restart preview callbacks
1498
if(mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME)
1500
mAppCallbackNotifier->enableMsgType (CAMERA_MSG_PREVIEW_FRAME);
1506
required_buffer_count = atoi(mCameraProperties->get(CameraProperties::REQUIRED_PREVIEW_BUFS));
1508
///Allocate the preview buffers
1509
ret = allocPreviewBufs(mPreviewWidth, mPreviewHeight, mParameters.getPreviewFormat(), required_buffer_count, max_queueble_buffers);
1511
if ( NO_ERROR != ret )
1513
CAMHAL_LOGEA("Couldn't allocate buffers for Preview");
1517
if ( mMeasurementEnabled )
1520
ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_PREVIEW_DATA,
1522
required_buffer_count);
1523
if ( NO_ERROR != ret )
1528
///Allocate the preview data buffers
1529
ret = allocPreviewDataBufs(frame.mLength, required_buffer_count);
1530
if ( NO_ERROR != ret ) {
1531
CAMHAL_LOGEA("Couldn't allocate preview data buffers");
1535
if ( NO_ERROR == ret )
1537
desc.mBuffers = mPreviewDataBufs;
1538
desc.mOffsets = mPreviewDataOffsets;
1539
desc.mFd = mPreviewDataFd;
1540
desc.mLength = mPreviewDataLength;
1541
desc.mCount = ( size_t ) required_buffer_count;
1542
desc.mMaxQueueable = (size_t) required_buffer_count;
1544
mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_PREVIEW_DATA,
1550
///Pass the buffers to Camera Adapter
1551
desc.mBuffers = mPreviewBufs;
1552
desc.mOffsets = mPreviewOffsets;
1553
desc.mFd = mPreviewFd;
1554
desc.mLength = mPreviewLength;
1555
desc.mCount = ( size_t ) required_buffer_count;
1556
desc.mMaxQueueable = (size_t) max_queueble_buffers;
1558
ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_PREVIEW,
1561
if ( NO_ERROR != ret )
1563
CAMHAL_LOGEB("Failed to register preview buffers: 0x%x", ret);
1568
mAppCallbackNotifier->startPreviewCallbacks(mParameters, mPreviewBufs, mPreviewOffsets, mPreviewFd, mPreviewLength, required_buffer_count);
1570
///Start the callback notifier
1571
ret = mAppCallbackNotifier->start();
1573
if( ALREADY_EXISTS == ret )
1575
//Already running, do nothing
1576
CAMHAL_LOGDA("AppCallbackNotifier already running");
1579
else if ( NO_ERROR == ret ) {
1580
CAMHAL_LOGDA("Started AppCallbackNotifier..");
1581
mAppCallbackNotifier->setMeasurements(mMeasurementEnabled);
1585
CAMHAL_LOGDA("Couldn't start AppCallbackNotifier");
1589
///Enable the display adapter if present, actual overlay enable happens when we post the buffer
1590
if(mDisplayAdapter.get() != NULL)
1592
CAMHAL_LOGDA("Enabling display");
1594
DisplayAdapter::S3DParameters s3dParams;
1596
mParameters.getPreviewSize(&width, &height);
1597
#if 0 //TODO: s3d is not part of bringup...will reenable
1598
if ( (valstr = mParameters.get(TICameraParameters::KEY_S3D_SUPPORTED)) != NULL) {
1599
isS3d = (strcmp(valstr, "true") == 0);
1601
if ( (valstr = mParameters.get(TICameraParameters::KEY_S3D2D_PREVIEW)) != NULL) {
1602
if (strcmp(valstr, "off") == 0)
1604
CAMHAL_LOGEA("STEREO 3D->2D PREVIEW MODE IS OFF");
1605
//TODO: obtain the frame packing configuration from camera or user settings
1606
//once side by side configuration is supported
1607
s3dParams.mode = OVERLAY_S3D_MODE_ON;
1608
s3dParams.framePacking = OVERLAY_S3D_FORMAT_OVERUNDER;
1609
s3dParams.order = OVERLAY_S3D_ORDER_LF;
1610
s3dParams.subSampling = OVERLAY_S3D_SS_NONE;
1614
CAMHAL_LOGEA("STEREO 3D->2D PREVIEW MODE IS ON");
1615
s3dParams.mode = OVERLAY_S3D_MODE_OFF;
1616
s3dParams.framePacking = OVERLAY_S3D_FORMAT_OVERUNDER;
1617
s3dParams.order = OVERLAY_S3D_ORDER_LF;
1618
s3dParams.subSampling = OVERLAY_S3D_SS_NONE;
1623
#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
1625
ret = mDisplayAdapter->enableDisplay(width, height, &mStartPreview, isS3d ? &s3dParams : NULL);
1629
ret = mDisplayAdapter->enableDisplay(width, height, NULL, isS3d ? &s3dParams : NULL);
1633
if ( ret != NO_ERROR )
1635
CAMHAL_LOGEA("Couldn't enable display");
1641
///Send START_PREVIEW command to adapter
1642
CAMHAL_LOGDA("Starting CameraAdapter preview mode");
1644
ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_PREVIEW);
1648
CAMHAL_LOGEA("Couldn't start preview w/ CameraAdapter");
1651
CAMHAL_LOGDA("Started preview");
1653
mPreviewEnabled = true;
1654
mPreviewStartInProgress = false;
1659
CAMHAL_LOGEA("Performing cleanup after error");
1661
//Do all the cleanup
1663
mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_PREVIEW);
1664
if(mDisplayAdapter.get() != NULL)
1666
mDisplayAdapter->disableDisplay(false);
1668
mAppCallbackNotifier->stop();
1669
mPreviewStartInProgress = false;
1670
mPreviewEnabled = false;
1671
LOG_FUNCTION_NAME_EXIT;
1677
@brief Sets ANativeWindow object.
1679
Preview buffers provided to CameraHal via this object. DisplayAdapter will be interfacing with it
1680
to render buffers to display.
1682
@param[in] window The ANativeWindow object created by Surface flinger
1683
@return NO_ERROR If the ANativeWindow object passes validation criteria
1684
@todo Define validation criteria for ANativeWindow object. Define error codes for scenarios
1687
status_t CameraHal::setPreviewWindow(struct preview_stream_ops *window)
1689
status_t ret = NO_ERROR;
1690
CameraAdapter::BuffersDescriptor desc;
1693
mSetPreviewWindowCalled = true;
1695
///If the Camera service passes a null window, we destroy existing window and free the DisplayAdapter
1698
if(mDisplayAdapter.get() != NULL)
1700
///NULL window passed, destroy the display adapter if present
1701
CAMHAL_LOGDA("NULL window passed, destroying display adapter");
1702
mDisplayAdapter.clear();
1703
///@remarks If there was a window previously existing, we usually expect another valid window to be passed by the client
1704
///@remarks so, we will wait until it passes a valid window to begin the preview again
1705
mSetPreviewWindowCalled = false;
1707
CAMHAL_LOGDA("NULL ANativeWindow passed to setPreviewWindow");
1709
}else if(mDisplayAdapter.get() == NULL)
1711
// Need to create the display adapter since it has not been created
1712
// Create display adapter
1713
mDisplayAdapter = new ANativeWindowDisplayAdapter();
1715
if(!mDisplayAdapter.get() || ((ret=mDisplayAdapter->initialize())!=NO_ERROR))
1719
mDisplayAdapter.clear();
1720
CAMHAL_LOGEA("DisplayAdapter initialize failed");
1721
LOG_FUNCTION_NAME_EXIT;
1726
CAMHAL_LOGEA("Couldn't create DisplayAdapter");
1727
LOG_FUNCTION_NAME_EXIT;
1732
// DisplayAdapter needs to know where to get the CameraFrames from inorder to display
1733
// Since CameraAdapter is the one that provides the frames, set it as the frame provider for DisplayAdapter
1734
mDisplayAdapter->setFrameProvider(mCameraAdapter);
1736
// Any dynamic errors that happen during the camera use case has to be propagated back to the application
1737
// via CAMERA_MSG_ERROR. AppCallbackNotifier is the class that notifies such errors to the application
1738
// Set it as the error handler for the DisplayAdapter
1739
mDisplayAdapter->setErrorHandler(mAppCallbackNotifier.get());
1741
// Update the display adapter with the new window that is passed from CameraService
1742
ret = mDisplayAdapter->setPreviewWindow(window);
1745
CAMHAL_LOGEB("DisplayAdapter setPreviewWindow returned error %d", ret);
1748
if(mPreviewStartInProgress)
1750
CAMHAL_LOGDA("setPreviewWindow called when preview running");
1751
// Start the preview since the window is now available
1752
ret = startPreview();
1755
// Update the display adapter with the new window that is passed from CameraService
1756
ret = mDisplayAdapter->setPreviewWindow(window);
1757
if ( (NO_ERROR == ret) && previewEnabled() ) {
1759
} else if (ret == ALREADY_EXISTS) {
1760
// ALREADY_EXISTS should be treated as a noop in this case
1764
LOG_FUNCTION_NAME_EXIT;
1772
@brief Stop a previously started preview.
1778
void CameraHal::stopPreview()
1782
if( (!previewEnabled() && !mDisplayPaused) || mRecordingEnabled)
1784
LOG_FUNCTION_NAME_EXIT;
1788
bool imageCaptureRunning = (mCameraAdapter->getState() == CameraAdapter::CAPTURE_STATE) &&
1789
(mCameraAdapter->getNextState() != CameraAdapter::PREVIEW_STATE);
1790
if(mDisplayPaused && !imageCaptureRunning)
1792
// Display is paused, which essentially means there is no preview active.
1793
// Note: this is done so that when stopPreview is called by client after
1794
// an image capture, we do not de-initialize the camera adapter and
1795
// restart over again.
1802
// Reset Capture-Mode to default, so that when we switch from VideoRecording
1803
// to ImageCapture, CAPTURE_MODE is not left to VIDEO_MODE.
1804
CAMHAL_LOGDA("Resetting Capture-Mode to default");
1805
mParameters.set(TICameraParameters::KEY_CAP_MODE, "");
1807
LOG_FUNCTION_NAME_EXIT;
1811
@brief Returns true if preview is enabled
1814
@return true If preview is running currently
1815
false If preview has been stopped
1818
bool CameraHal::previewEnabled()
1822
return (mPreviewEnabled || mPreviewStartInProgress);
1826
@brief Start record mode.
1828
When a record image is available a CAMERA_MSG_VIDEO_FRAME message is sent with
1829
the corresponding frame. Every record frame must be released by calling
1830
releaseRecordingFrame().
1833
@return NO_ERROR If recording could be started without any issues
1834
@todo Update the header with possible error values in failure scenarios
1837
status_t CameraHal::startRecording( )
1840
const char *valstr = NULL;
1841
bool restartPreviewRequired = false;
1842
status_t ret = NO_ERROR;
1847
#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
1849
gettimeofday(&mStartPreview, NULL);
1853
if(!previewEnabled())
1858
// set internal recording hint in case camera adapter needs to make some
1859
// decisions....(will only be sent to camera adapter if camera restart is required)
1860
mParameters.set(TICameraParameters::KEY_RECORDING_HINT, CameraParameters::TRUE);
1862
// if application starts recording in continuous focus picture mode...
1863
// then we need to force default capture mode (as opposed to video mode)
1864
if ( ((valstr = mParameters.get(CameraParameters::KEY_FOCUS_MODE)) != NULL) &&
1865
(strcmp(valstr, CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE) == 0) ){
1866
restartPreviewRequired = resetVideoModeParameters();
1869
// only need to check recording hint if preview restart is not already needed
1870
valstr = mParameters.get(CameraParameters::KEY_RECORDING_HINT);
1871
if ( !restartPreviewRequired &&
1872
(!valstr || (valstr && (strcmp(valstr, CameraParameters::TRUE) != 0))) ) {
1873
restartPreviewRequired = setVideoModeParameters(mParameters);
1876
if (restartPreviewRequired) {
1877
ret = restartPreview();
1880
if ( NO_ERROR == ret )
1882
int count = atoi(mCameraProperties->get(CameraProperties::REQUIRED_PREVIEW_BUFS));
1883
mParameters.getPreviewSize(&w, &h);
1884
CAMHAL_LOGDB("%s Video Width=%d Height=%d", __FUNCTION__, mVideoWidth, mVideoHeight);
1886
if ((w != mVideoWidth) && (h != mVideoHeight))
1888
ret = allocVideoBufs(mVideoWidth, mVideoHeight, count);
1889
if ( NO_ERROR != ret )
1891
CAMHAL_LOGEB("allocImageBufs returned error 0x%x", ret);
1892
mParameters.remove(TICameraParameters::KEY_RECORDING_HINT);
1896
mAppCallbackNotifier->useVideoBuffers(true);
1897
mAppCallbackNotifier->setVideoRes(mVideoWidth, mVideoHeight);
1898
ret = mAppCallbackNotifier->initSharedVideoBuffers(mPreviewBufs, mPreviewOffsets, mPreviewFd, mPreviewLength, count, mVideoBufs);
1902
mAppCallbackNotifier->useVideoBuffers(false);
1903
mAppCallbackNotifier->setVideoRes(mPreviewWidth, mPreviewHeight);
1904
ret = mAppCallbackNotifier->initSharedVideoBuffers(mPreviewBufs, mPreviewOffsets, mPreviewFd, mPreviewLength, count, NULL);
1908
if ( NO_ERROR == ret )
1910
ret = mAppCallbackNotifier->startRecording();
1913
if ( NO_ERROR == ret )
1915
///Buffers for video capture (if different from preview) are expected to be allocated within CameraAdapter
1916
ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_VIDEO);
1919
if ( NO_ERROR == ret )
1921
mRecordingEnabled = true;
1924
LOG_FUNCTION_NAME_EXIT;
1930
@brief Set the camera parameters specific to Video Recording.
1932
This function checks for the camera parameters which have to be set for recording.
1933
Video Recording needs CAPTURE_MODE to be VIDEO_MODE. This function sets it.
1934
This function also enables Video Recording specific functions like VSTAB & VNF.
1937
@return true if preview needs to be restarted for VIDEO_MODE parameters to take effect.
1938
@todo Modify the policies for enabling VSTAB & VNF usecase based later.
1941
bool CameraHal::setVideoModeParameters(const CameraParameters& params)
1943
const char *valstr = NULL;
1944
const char *valstrRemote = NULL;
1945
bool restartPreviewRequired = false;
1946
status_t ret = NO_ERROR;
1950
// Set CAPTURE_MODE to VIDEO_MODE, if not set already and Restart Preview
1951
valstr = mParameters.get(TICameraParameters::KEY_CAP_MODE);
1952
if ( (valstr == NULL) ||
1953
( (valstr != NULL) && (strcmp(valstr, (const char *) TICameraParameters::VIDEO_MODE) != 0) ) )
1955
CAMHAL_LOGDA("Set CAPTURE_MODE to VIDEO_MODE");
1956
mParameters.set(TICameraParameters::KEY_CAP_MODE, (const char *) TICameraParameters::VIDEO_MODE);
1957
restartPreviewRequired = true;
1960
// Check if CAPTURE_MODE is VIDEO_MODE, since VSTAB & VNF work only in VIDEO_MODE.
1961
valstr = mParameters.get(TICameraParameters::KEY_CAP_MODE);
1962
if (strcmp(valstr, (const char *) TICameraParameters::VIDEO_MODE) == 0) {
1963
valstrRemote = params.get(CameraParameters::KEY_VIDEO_STABILIZATION);
1964
// set VSTAB. restart is required if vstab value has changed
1965
if ( valstrRemote != NULL) {
1966
// make sure we support vstab
1967
if (strcmp(mCameraProperties->get(CameraProperties::VSTAB_SUPPORTED),
1968
CameraParameters::TRUE) == 0) {
1969
valstr = mParameters.get(CameraParameters::KEY_VIDEO_STABILIZATION);
1970
// vstab value has changed
1971
if ((valstr != NULL) &&
1972
strcmp(valstr, valstrRemote) != 0) {
1973
restartPreviewRequired = true;
1975
mParameters.set(CameraParameters::KEY_VIDEO_STABILIZATION, valstrRemote);
1977
} else if (mParameters.get(CameraParameters::KEY_VIDEO_STABILIZATION)) {
1978
// vstab was configured but now unset
1979
restartPreviewRequired = true;
1980
mParameters.remove(CameraParameters::KEY_VIDEO_STABILIZATION);
1984
valstrRemote = params.get(TICameraParameters::KEY_VNF);
1985
if ( valstrRemote == NULL) {
1986
CAMHAL_LOGDA("Enable VNF");
1987
mParameters.set(TICameraParameters::KEY_VNF, "1");
1988
restartPreviewRequired = true;
1990
valstr = mParameters.get(TICameraParameters::KEY_VNF);
1991
if (valstr && strcmp(valstr, valstrRemote) != 0) {
1992
restartPreviewRequired = true;
1994
mParameters.set(TICameraParameters::KEY_VNF, valstrRemote);
1997
// For VSTAB alone for 1080p resolution, padded width goes > 2048, which cannot be rendered by GPU.
1998
// In such case, there is support in Ducati for combination of VSTAB & VNF requiring padded width < 2048.
1999
// So we are forcefully enabling VNF, if VSTAB is enabled for 1080p resolution.
2000
valstr = mParameters.get(CameraParameters::KEY_VIDEO_STABILIZATION);
2001
if (valstr && (strcmp(valstr, CameraParameters::TRUE) == 0) && (mPreviewWidth == 1920)) {
2002
CAMHAL_LOGDA("Force Enable VNF for 1080p");
2003
mParameters.set(TICameraParameters::KEY_VNF, "1");
2004
restartPreviewRequired = true;
2007
LOG_FUNCTION_NAME_EXIT;
2009
return restartPreviewRequired;
2013
@brief Reset the camera parameters specific to Video Recording.
2015
This function resets CAPTURE_MODE and disables Recording specific functions like VSTAB & VNF.
2018
@return true if preview needs to be restarted for VIDEO_MODE parameters to take effect.
2021
bool CameraHal::resetVideoModeParameters()
2023
const char *valstr = NULL;
2024
bool restartPreviewRequired = false;
2025
status_t ret = NO_ERROR;
2029
// ignore this if we are already recording
2030
if (mRecordingEnabled) {
2034
// Set CAPTURE_MODE to VIDEO_MODE, if not set already and Restart Preview
2035
valstr = mParameters.get(TICameraParameters::KEY_CAP_MODE);
2036
if ((valstr != NULL) && (strcmp(valstr, TICameraParameters::VIDEO_MODE) == 0)) {
2037
CAMHAL_LOGDA("Reset Capture-Mode to default");
2038
mParameters.set(TICameraParameters::KEY_CAP_MODE, "");
2039
restartPreviewRequired = true;
2042
LOG_FUNCTION_NAME_EXIT;
2044
return restartPreviewRequired;
2048
@brief Restart the preview with setParameter.
2050
This function restarts preview, for some VIDEO_MODE parameters to take effect.
2053
@return NO_ERROR If recording parameters could be set without any issues
2056
status_t CameraHal::restartPreview()
2058
const char *valstr = NULL;
2060
status_t ret = NO_ERROR;
2064
// Retain CAPTURE_MODE before calling stopPreview(), since it is reset in stopPreview().
2066
valstr = mParameters.get(TICameraParameters::KEY_CAP_MODE);
2069
if(sizeof(tmpvalstr) < (strlen(valstr)+1))
2074
strncpy(tmpvalstr, valstr, sizeof(tmpvalstr));
2075
tmpvalstr[sizeof(tmpvalstr)-1] = 0;
2081
Mutex::Autolock lock(mLock);
2082
mParameters.set(TICameraParameters::KEY_CAP_MODE, tmpvalstr);
2083
mCameraAdapter->setParameters(mParameters);
2086
ret = startPreview();
2088
LOG_FUNCTION_NAME_EXIT;
2094
@brief Stop a previously started recording.
2100
void CameraHal::stopRecording()
2102
CameraAdapter::AdapterState currentState;
2106
Mutex::Autolock lock(mLock);
2108
if (!mRecordingEnabled )
2113
currentState = mCameraAdapter->getState();
2114
if (currentState == CameraAdapter::VIDEO_CAPTURE_STATE) {
2115
mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_IMAGE_CAPTURE);
2118
mAppCallbackNotifier->stopRecording();
2120
mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_VIDEO);
2122
mRecordingEnabled = false;
2124
if ( mAppCallbackNotifier->getUesVideoBuffers() ){
2125
freeVideoBufs(mVideoBufs);
2127
CAMHAL_LOGVB(" FREEING mVideoBufs 0x%x", mVideoBufs);
2128
delete [] mVideoBufs;
2133
// reset internal recording hint in case camera adapter needs to make some
2134
// decisions....(will only be sent to camera adapter if camera restart is required)
2135
mParameters.remove(TICameraParameters::KEY_RECORDING_HINT);
2137
LOG_FUNCTION_NAME_EXIT;
2141
@brief Returns true if recording is enabled.
2144
@return true If recording is currently running
2145
false If recording has been stopped
2148
int CameraHal::recordingEnabled()
2152
LOG_FUNCTION_NAME_EXIT;
2154
return mRecordingEnabled;
2158
@brief Release a record frame previously returned by CAMERA_MSG_VIDEO_FRAME.
2160
@param[in] mem MemoryBase pointer to the frame being released. Must be one of the buffers
2161
previously given by CameraHal
2165
void CameraHal::releaseRecordingFrame(const void* mem)
2169
//CAMHAL_LOGDB(" 0x%x", mem->pointer());
2171
if ( ( mRecordingEnabled ) && mem != NULL)
2173
mAppCallbackNotifier->releaseRecordingFrame(mem);
2176
LOG_FUNCTION_NAME_EXIT;
2182
@brief Start auto focus
2184
This call asynchronous.
2185
The notification callback routine is called with CAMERA_MSG_FOCUS once when
2186
focusing is complete. autoFocus() will be called again if another auto focus is
2191
@todo Define the error codes if the focus is not locked
2194
status_t CameraHal::autoFocus()
2196
status_t ret = NO_ERROR;
2198
#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
2200
gettimeofday(&mStartFocus, NULL);
2206
Mutex::Autolock lock(mLock);
2208
mMsgEnabled |= CAMERA_MSG_FOCUS;
2210
if ( NULL == mCameraAdapter )
2216
CameraAdapter::AdapterState state;
2217
ret = mCameraAdapter->getState(state);
2218
if (ret != NO_ERROR)
2223
if (state == CameraAdapter::AF_STATE)
2225
CAMHAL_LOGI("Ignoring start-AF (already in progress)");
2229
#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
2231
//pass the autoFocus timestamp along with the command to camera adapter
2232
ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_PERFORM_AUTOFOCUS, ( int ) &mStartFocus);
2236
ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_PERFORM_AUTOFOCUS);
2241
LOG_FUNCTION_NAME_EXIT;
2247
@brief Cancels auto-focus function.
2249
If the auto-focus is still in progress, this function will cancel it.
2250
Whether the auto-focus is in progress or not, this function will return the
2251
focus position to the default. If the camera does not support auto-focus, this is a no-op.
2255
@return NO_ERROR If the cancel succeeded
2256
@todo Define error codes if cancel didnt succeed
2259
status_t CameraHal::cancelAutoFocus()
2263
Mutex::Autolock lock(mLock);
2264
CameraParameters adapterParams = mParameters;
2265
mMsgEnabled &= ~CAMERA_MSG_FOCUS;
2267
if( NULL != mCameraAdapter )
2269
adapterParams.set(TICameraParameters::KEY_AUTO_FOCUS_LOCK, CameraParameters::FALSE);
2270
mCameraAdapter->setParameters(adapterParams);
2271
mCameraAdapter->sendCommand(CameraAdapter::CAMERA_CANCEL_AUTOFOCUS);
2272
mAppCallbackNotifier->flushEventQueue();
2275
LOG_FUNCTION_NAME_EXIT;
2279
void CameraHal::setEventProvider(int32_t eventMask, MessageNotifier * eventNotifier)
2284
if ( NULL != mEventProvider )
2286
mEventProvider->disableEventNotification(CameraHalEvent::ALL_EVENTS);
2287
delete mEventProvider;
2288
mEventProvider = NULL;
2291
mEventProvider = new EventProvider(eventNotifier, this, eventCallbackRelay);
2292
if ( NULL == mEventProvider )
2294
CAMHAL_LOGEA("Error in creating EventProvider");
2298
mEventProvider->enableEventNotification(eventMask);
2301
LOG_FUNCTION_NAME_EXIT;
2304
void CameraHal::eventCallbackRelay(CameraHalEvent* event)
2308
CameraHal *appcbn = ( CameraHal * ) (event->mCookie);
2309
appcbn->eventCallback(event );
2311
LOG_FUNCTION_NAME_EXIT;
2314
void CameraHal::eventCallback(CameraHalEvent* event)
2318
if ( NULL != event )
2320
switch( event->mEventType )
2322
case CameraHalEvent::EVENT_FOCUS_LOCKED:
2323
case CameraHalEvent::EVENT_FOCUS_ERROR:
2325
if ( mBracketingEnabled )
2327
startImageBracketing();
2338
LOG_FUNCTION_NAME_EXIT;
2341
status_t CameraHal::startImageBracketing()
2343
status_t ret = NO_ERROR;
2345
CameraAdapter::BuffersDescriptor desc;
2347
#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
2349
gettimeofday(&mStartCapture, NULL);
2355
if(!previewEnabled() && !mDisplayPaused)
2357
LOG_FUNCTION_NAME_EXIT;
2361
if ( !mBracketingEnabled )
2366
if ( NO_ERROR == ret )
2368
mBracketingRunning = true;
2371
if ( (NO_ERROR == ret) && ( NULL != mCameraAdapter ) )
2373
ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE,
2375
( mBracketRangeNegative + 1 ));
2377
if ( NO_ERROR != ret )
2379
CAMHAL_LOGEB("CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE returned error 0x%x", ret);
2383
if ( NO_ERROR == ret )
2385
if ( NULL != mAppCallbackNotifier.get() )
2387
mAppCallbackNotifier->setBurst(true);
2391
if ( NO_ERROR == ret )
2393
mParameters.getPictureSize(( int * ) &frame.mWidth,
2394
( int * ) &frame.mHeight);
2396
ret = allocImageBufs(frame.mWidth,
2399
mParameters.getPictureFormat(),
2400
( mBracketRangeNegative + 1 ));
2401
if ( NO_ERROR != ret )
2403
CAMHAL_LOGEB("allocImageBufs returned error 0x%x", ret);
2407
if ( (NO_ERROR == ret) && ( NULL != mCameraAdapter ) )
2410
desc.mBuffers = mImageBufs;
2411
desc.mOffsets = mImageOffsets;
2412
desc.mFd = mImageFd;
2413
desc.mLength = mImageLength;
2414
desc.mCount = ( size_t ) ( mBracketRangeNegative + 1 );
2415
desc.mMaxQueueable = ( size_t ) ( mBracketRangeNegative + 1 );
2417
ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_IMAGE_CAPTURE,
2420
if ( NO_ERROR == ret )
2423
#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
2425
//pass capture timestamp along with the camera adapter command
2426
ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_BRACKET_CAPTURE, ( mBracketRangePositive + 1 ), (int) &mStartCapture);
2430
ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_BRACKET_CAPTURE, ( mBracketRangePositive + 1 ));
2440
status_t CameraHal::stopImageBracketing()
2442
status_t ret = NO_ERROR;
2446
if( !previewEnabled() )
2451
mBracketingRunning = false;
2453
ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_BRACKET_CAPTURE);
2455
LOG_FUNCTION_NAME_EXIT;
2461
@brief Take a picture.
2464
@return NO_ERROR If able to switch to image capture
2465
@todo Define error codes if unable to switch to image capture
2468
status_t CameraHal::takePicture( )
2470
status_t ret = NO_ERROR;
2472
CameraAdapter::BuffersDescriptor desc;
2474
const char *valstr = NULL;
2475
unsigned int bufferCount = 1;
2477
Mutex::Autolock lock(mLock);
2479
#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
2481
gettimeofday(&mStartCapture, NULL);
2487
if(!previewEnabled() && !mDisplayPaused)
2489
LOG_FUNCTION_NAME_EXIT;
2490
CAMHAL_LOGEA("Preview not started...");
2494
// return error if we are already capturing
2495
if ( (mCameraAdapter->getState() == CameraAdapter::CAPTURE_STATE &&
2496
mCameraAdapter->getNextState() != CameraAdapter::PREVIEW_STATE) ||
2497
(mCameraAdapter->getState() == CameraAdapter::VIDEO_CAPTURE_STATE &&
2498
mCameraAdapter->getNextState() != CameraAdapter::VIDEO_STATE) ) {
2499
CAMHAL_LOGEA("Already capturing an image...");
2503
// we only support video snapshot if we are in video mode (recording hint is set)
2504
valstr = mParameters.get(TICameraParameters::KEY_CAP_MODE);
2505
if ( (mCameraAdapter->getState() == CameraAdapter::VIDEO_STATE) &&
2506
(valstr && strcmp(valstr, TICameraParameters::VIDEO_MODE)) ) {
2507
CAMHAL_LOGEA("Trying to capture while recording without recording hint set...");
2508
return INVALID_OPERATION;
2511
if ( !mBracketingRunning )
2514
if ( NO_ERROR == ret )
2516
burst = mParameters.getInt(TICameraParameters::KEY_BURST);
2519
//Allocate all buffers only in burst capture case
2522
bufferCount = CameraHal::NO_BUFFERS_IMAGE_CAPTURE;
2523
if ( NULL != mAppCallbackNotifier.get() )
2525
mAppCallbackNotifier->setBurst(true);
2530
if ( NULL != mAppCallbackNotifier.get() )
2532
mAppCallbackNotifier->setBurst(false);
2536
// pause preview during normal image capture
2537
// do not pause preview if recording (video state)
2538
if (NO_ERROR == ret &&
2539
NULL != mDisplayAdapter.get() &&
2541
if (mCameraAdapter->getState() != CameraAdapter::VIDEO_STATE) {
2542
mDisplayPaused = true;
2543
mPreviewEnabled = false;
2544
ret = mDisplayAdapter->pauseDisplay(mDisplayPaused);
2545
// since preview is paused we should stop sending preview frames too
2546
if(mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME) {
2547
mAppCallbackNotifier->disableMsgType (CAMERA_MSG_PREVIEW_FRAME);
2551
#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
2552
mDisplayAdapter->setSnapshotTimeRef(&mStartCapture);
2556
// if we taking video snapshot...
2557
if ((NO_ERROR == ret) && (mCameraAdapter->getState() == CameraAdapter::VIDEO_STATE)) {
2558
// enable post view frames if not already enabled so we can internally
2559
// save snapshot frames for generating thumbnail
2560
if((mMsgEnabled & CAMERA_MSG_POSTVIEW_FRAME) == 0) {
2561
mAppCallbackNotifier->enableMsgType(CAMERA_MSG_POSTVIEW_FRAME);
2565
if ( (NO_ERROR == ret) && (NULL != mCameraAdapter) )
2567
if ( NO_ERROR == ret )
2568
ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE,
2572
if ( NO_ERROR != ret )
2574
CAMHAL_LOGEB("CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE returned error 0x%x", ret);
2578
if ( NO_ERROR == ret )
2580
mParameters.getPictureSize(( int * ) &frame.mWidth,
2581
( int * ) &frame.mHeight);
2583
ret = allocImageBufs(frame.mWidth,
2586
mParameters.getPictureFormat(),
2588
if ( NO_ERROR != ret )
2590
CAMHAL_LOGEB("allocImageBufs returned error 0x%x", ret);
2594
if ( (NO_ERROR == ret) && ( NULL != mCameraAdapter ) )
2596
desc.mBuffers = mImageBufs;
2597
desc.mOffsets = mImageOffsets;
2598
desc.mFd = mImageFd;
2599
desc.mLength = mImageLength;
2600
desc.mCount = ( size_t ) bufferCount;
2601
desc.mMaxQueueable = ( size_t ) bufferCount;
2603
ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_IMAGE_CAPTURE,
2608
if ( ( NO_ERROR == ret ) && ( NULL != mCameraAdapter ) )
2611
#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
2613
//pass capture timestamp along with the camera adapter command
2614
ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_IMAGE_CAPTURE, (int) &mStartCapture);
2618
ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_IMAGE_CAPTURE);
2628
@brief Cancel a picture that was started with takePicture.
2630
Calling this method when no picture is being taken is a no-op.
2633
@return NO_ERROR If cancel succeeded. Cancel can succeed if image callback is not sent
2634
@todo Define error codes
2637
status_t CameraHal::cancelPicture( )
2641
Mutex::Autolock lock(mLock);
2643
mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_IMAGE_CAPTURE);
2649
@brief Return the camera parameters.
2652
@return Currently configured camera parameters
2655
char* CameraHal::getParameters()
2657
String8 params_str8;
2658
char* params_string;
2659
const char * valstr = NULL;
2663
if( NULL != mCameraAdapter )
2665
mCameraAdapter->getParameters(mParameters);
2668
CameraParameters mParams = mParameters;
2670
// Handle RECORDING_HINT to Set/Reset Video Mode Parameters
2671
valstr = mParameters.get(CameraParameters::KEY_RECORDING_HINT);
2674
if(strcmp(valstr, CameraParameters::TRUE) == 0)
2677
resetPreviewRes(&mParams, mVideoWidth, mVideoHeight);
2681
// do not send internal parameters to upper layers
2682
mParams.remove(TICameraParameters::KEY_RECORDING_HINT);
2683
mParams.remove(TICameraParameters::KEY_AUTO_FOCUS_LOCK);
2685
params_str8 = mParams.flatten();
2687
// camera service frees this string...
2688
params_string = (char*) malloc(sizeof(char) * (params_str8.length()+1));
2689
strcpy(params_string, params_str8.string());
2691
LOG_FUNCTION_NAME_EXIT;
2693
///Return the current set of parameters
2695
return params_string;
2698
void CameraHal::putParameters(char *parms)
2704
@brief Send command to camera driver.
2707
@return NO_ERROR If the command succeeds
2708
@todo Define the error codes that this function can return
2711
status_t CameraHal::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2)
2713
status_t ret = NO_ERROR;
2718
if ( ( NO_ERROR == ret ) && ( NULL == mCameraAdapter ) )
2720
CAMHAL_LOGEA("No CameraAdapter instance");
2724
///////////////////////////////////////////////////////
2725
// Following commands do NOT need preview to be started
2726
///////////////////////////////////////////////////////
2728
case CAMERA_CMD_ENABLE_FOCUS_MOVE_MSG:
2729
bool enable = static_cast<bool>(arg1);
2730
Mutex::Autolock lock(mLock);
2732
mMsgEnabled |= CAMERA_MSG_FOCUS_MOVE;
2734
mMsgEnabled &= ~CAMERA_MSG_FOCUS_MOVE;
2740
if ( ( NO_ERROR == ret ) && ( !previewEnabled() ))
2742
CAMHAL_LOGEA("Preview is not running");
2746
///////////////////////////////////////////////////////
2747
// Following commands NEED preview to be started
2748
///////////////////////////////////////////////////////
2750
if ( NO_ERROR == ret )
2754
case CAMERA_CMD_START_SMOOTH_ZOOM:
2756
ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_SMOOTH_ZOOM, arg1);
2759
case CAMERA_CMD_STOP_SMOOTH_ZOOM:
2761
ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_SMOOTH_ZOOM);
2763
case CAMERA_CMD_START_FACE_DETECTION:
2765
ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_FD);
2769
case CAMERA_CMD_STOP_FACE_DETECTION:
2771
ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_FD);
2780
LOG_FUNCTION_NAME_EXIT;
2786
@brief Release the hardware resources owned by this object.
2788
Note that this is *not* done in the destructor.
2794
void CameraHal::release()
2797
///@todo Investigate on how release is used by CameraService. Vaguely remember that this is called
2798
///just before CameraHal object destruction
2800
LOG_FUNCTION_NAME_EXIT;
2805
@brief Dump state of the camera hardware
2807
@param[in] fd File descriptor
2808
@param[in] args Arguments
2809
@return NO_ERROR Dump succeeded
2810
@todo Error codes for dump fail
2813
status_t CameraHal::dump(int fd) const
2816
///Implement this method when the h/w dump function is supported on Ducati side
2820
/*-------------Camera Hal Interface Method definitions ENDS here--------------------*/
2825
/*-------------Camera Hal Internal Method definitions STARTS here--------------------*/
2828
@brief Constructor of CameraHal
2830
Member variables are initialized here. No allocations should be done here as we
2831
don't use c++ exceptions in the code.
2834
CameraHal::CameraHal(int cameraId)
2838
///Initialize all the member variables to their defaults
2839
mPreviewEnabled = false;
2840
mPreviewBufs = NULL;
2842
mBufProvider = NULL;
2843
mPreviewStartInProgress = false;
2845
mVideoBufProvider = NULL;
2846
mRecordingEnabled = false;
2847
mDisplayPaused = false;
2848
mSetPreviewWindowCalled = false;
2850
mAppCallbackNotifier = NULL;
2851
mMemoryManager = NULL;
2852
mCameraAdapter = NULL;
2853
mBracketingEnabled = false;
2854
mBracketingRunning = false;
2855
mEventProvider = NULL;
2856
mBracketRangePositive = 1;
2857
mBracketRangeNegative = 1;
2858
mMaxZoomSupported = 0;
2859
mShutterEnabled = true;
2860
mMeasurementEnabled = false;
2861
mPreviewDataBufs = NULL;
2862
mCameraProperties = NULL;
2865
mImageOffsets = NULL;
2868
mVideoOffsets = NULL;
2871
mPreviewDataOffsets = NULL;
2873
mPreviewDataLength = 0;
2878
mPreviewOffsets = NULL;
2879
mPreviewRunning = 0;
2880
mPreviewStateOld = 0;
2881
mRecordingEnabled = 0;
2883
mSensorListener = NULL;
2887
#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
2889
//Initialize the CameraHAL constructor timestamp, which is used in the
2890
// PPM() method as time reference if the user does not supply one.
2891
gettimeofday(&ppm_start, NULL);
2895
mCameraIndex = cameraId;
2897
LOG_FUNCTION_NAME_EXIT;
2901
@brief Destructor of CameraHal
2903
This function simply calls deinitialize() to free up memory allocate during construct
2906
CameraHal::~CameraHal()
2910
///Call de-initialize here once more - it is the last chance for us to relinquish all the h/w and s/w resources
2913
if ( NULL != mEventProvider )
2915
mEventProvider->disableEventNotification(CameraHalEvent::ALL_EVENTS);
2916
delete mEventProvider;
2917
mEventProvider = NULL;
2920
/// Free the callback notifier
2921
mAppCallbackNotifier.clear();
2923
/// Free the display adapter
2924
mDisplayAdapter.clear();
2926
if ( NULL != mCameraAdapter ) {
2927
int strongCount = mCameraAdapter->getStrongCount();
2929
mCameraAdapter->decStrong(mCameraAdapter);
2931
mCameraAdapter = NULL;
2936
/// Free the memory manager
2937
mMemoryManager.clear();
2939
LOG_FUNCTION_NAME_EXIT;
2943
@brief Initialize the Camera HAL
2945
Creates CameraAdapter, AppCallbackNotifier, DisplayAdapter and MemoryManager
2948
@return NO_ERROR - On success
2949
NO_MEMORY - On failure to allocate memory for any of the objects
2950
@remarks Camera Hal internal function
2954
status_t CameraHal::initialize(CameraProperties::Properties* properties)
2958
int sensor_index = 0;
2960
///Initialize the event mask used for registering an event provider for AppCallbackNotifier
2961
///Currently, registering all events as to be coming from CameraAdapter
2962
int32_t eventMask = CameraHalEvent::ALL_EVENTS;
2964
// Get my camera properties
2965
mCameraProperties = properties;
2967
if(!mCameraProperties)
2972
// Dump the properties of this Camera
2973
// will only print if DEBUG macro is defined
2974
mCameraProperties->dump();
2976
if (strcmp(CameraProperties::DEFAULT_VALUE, mCameraProperties->get(CameraProperties::CAMERA_SENSOR_INDEX)) != 0 )
2978
sensor_index = atoi(mCameraProperties->get(CameraProperties::CAMERA_SENSOR_INDEX));
2981
CAMHAL_LOGDB("Sensor index %d", sensor_index);
2983
mCameraAdapter = CameraAdapter_Factory(sensor_index);
2984
if ( ( NULL == mCameraAdapter ) || (mCameraAdapter->initialize(properties)!=NO_ERROR))
2986
CAMHAL_LOGEA("Unable to create or initialize CameraAdapter");
2987
mCameraAdapter = NULL;
2991
mCameraAdapter->incStrong(mCameraAdapter);
2992
mCameraAdapter->registerImageReleaseCallback(releaseImageBuffers, (void *) this);
2993
mCameraAdapter->registerEndCaptureCallback(endImageCapture, (void *)this);
2995
if(!mAppCallbackNotifier.get())
2997
/// Create the callback notifier
2998
mAppCallbackNotifier = new AppCallbackNotifier();
2999
if( ( NULL == mAppCallbackNotifier.get() ) || ( mAppCallbackNotifier->initialize() != NO_ERROR))
3001
CAMHAL_LOGEA("Unable to create or initialize AppCallbackNotifier");
3006
if(!mMemoryManager.get())
3008
/// Create Memory Manager
3009
mMemoryManager = new MemoryManager();
3010
if( ( NULL == mMemoryManager.get() ) || ( mMemoryManager->initialize() != NO_ERROR))
3012
CAMHAL_LOGEA("Unable to create or initialize MemoryManager");
3017
///Setup the class dependencies...
3019
///AppCallbackNotifier has to know where to get the Camera frames and the events like auto focus lock etc from.
3020
///CameraAdapter is the one which provides those events
3021
///Set it as the frame and event providers for AppCallbackNotifier
3022
///@remarks setEventProvider API takes in a bit mask of events for registering a provider for the different events
3023
/// That way, if events can come from DisplayAdapter in future, we will be able to add it as provider
3025
mAppCallbackNotifier->setEventProvider(eventMask, mCameraAdapter);
3026
mAppCallbackNotifier->setFrameProvider(mCameraAdapter);
3028
///Any dynamic errors that happen during the camera use case has to be propagated back to the application
3029
///via CAMERA_MSG_ERROR. AppCallbackNotifier is the class that notifies such errors to the application
3030
///Set it as the error handler for CameraAdapter
3031
mCameraAdapter->setErrorHandler(mAppCallbackNotifier.get());
3033
///Start the callback notifier
3034
if(mAppCallbackNotifier->start() != NO_ERROR)
3036
CAMHAL_LOGEA("Couldn't start AppCallbackNotifier");
3040
CAMHAL_LOGDA("Started AppCallbackNotifier..");
3041
mAppCallbackNotifier->setMeasurements(mMeasurementEnabled);
3043
///Initialize default parameters
3044
initDefaultParameters();
3047
if ( setParameters(mParameters) != NO_ERROR )
3049
CAMHAL_LOGEA("Failed to set default parameters?!");
3052
// register for sensor events
3053
mSensorListener = new SensorListener();
3054
if (mSensorListener.get()) {
3055
if (mSensorListener->initialize() == NO_ERROR) {
3056
mSensorListener->setCallbacks(orientation_cb, this);
3057
mSensorListener->enableSensor(SensorListener::SENSOR_ORIENTATION);
3059
CAMHAL_LOGEA("Error initializing SensorListener. not fatal, continuing");
3060
mSensorListener.clear();
3061
mSensorListener = NULL;
3065
LOG_FUNCTION_NAME_EXIT;
3071
///Free up the resources because we failed somewhere up
3073
LOG_FUNCTION_NAME_EXIT;
3079
bool CameraHal::isResolutionValid(unsigned int width, unsigned int height, const char *supportedResolutions)
3082
status_t status = NO_ERROR;
3083
char tmpBuffer[PARAM_BUFFER + 1];
3088
if ( NULL == supportedResolutions )
3090
CAMHAL_LOGEA("Invalid supported resolutions string");
3095
status = snprintf(tmpBuffer, PARAM_BUFFER, "%dx%d", width, height);
3098
CAMHAL_LOGEA("Error encountered while generating validation string");
3103
pos = strstr(supportedResolutions, tmpBuffer);
3115
LOG_FUNCTION_NAME_EXIT;
3120
bool CameraHal::isParameterValid(const char *param, const char *supportedParams)
3127
if ( NULL == supportedParams )
3129
CAMHAL_LOGEA("Invalid supported parameters string");
3134
if ( NULL == param )
3136
CAMHAL_LOGEA("Invalid parameter string");
3141
pos = strstr(supportedParams, param);
3153
LOG_FUNCTION_NAME_EXIT;
3158
bool CameraHal::isParameterValid(int param, const char *supportedParams)
3163
char tmpBuffer[PARAM_BUFFER + 1];
3167
if ( NULL == supportedParams )
3169
CAMHAL_LOGEA("Invalid supported parameters string");
3174
status = snprintf(tmpBuffer, PARAM_BUFFER, "%d", param);
3177
CAMHAL_LOGEA("Error encountered while generating validation string");
3182
pos = strstr(supportedParams, tmpBuffer);
3194
LOG_FUNCTION_NAME_EXIT;
3199
status_t CameraHal::doesSetParameterNeedUpdate(const char* new_param, const char* old_param, bool& update) {
3200
if (!new_param || !old_param) {
3204
// if params mismatch we should update parameters for camera adapter
3205
if ((strcmp(new_param, old_param) != 0)) {
3212
status_t CameraHal::parseResolution(const char *resStr, int &width, int &height)
3214
status_t ret = NO_ERROR;
3215
char *ctx, *pWidth, *pHeight;
3216
const char *sep = "x";
3221
if ( NULL == resStr )
3226
//This fixes "Invalid input resolution"
3227
char *resStr_copy = (char *)malloc(strlen(resStr) + 1);
3228
if ( NULL!=resStr_copy ) {
3229
if ( NO_ERROR == ret )
3231
strcpy(resStr_copy, resStr);
3232
pWidth = strtok_r( (char *) resStr_copy, sep, &ctx);
3234
if ( NULL != pWidth )
3236
width = atoi(pWidth);
3240
CAMHAL_LOGEB("Invalid input resolution %s", resStr);
3245
if ( NO_ERROR == ret )
3247
pHeight = strtok_r(NULL, sep, &ctx);
3249
if ( NULL != pHeight )
3251
height = atoi(pHeight);
3255
CAMHAL_LOGEB("Invalid input resolution %s", resStr);
3263
LOG_FUNCTION_NAME_EXIT;
3268
void CameraHal::insertSupportedParams()
3270
char tmpBuffer[PARAM_BUFFER + 1];
3274
CameraParameters &p = mParameters;
3276
///Set the name of the camera
3277
p.set(TICameraParameters::KEY_CAMERA_NAME, mCameraProperties->get(CameraProperties::CAMERA_NAME));
3279
mMaxZoomSupported = atoi(mCameraProperties->get(CameraProperties::SUPPORTED_ZOOM_STAGES));
3281
p.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_SIZES));
3282
p.set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_FORMATS));
3283
p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_SIZES));
3284
p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FORMATS));
3285
p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FRAME_RATES));
3286
p.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_THUMBNAIL_SIZES));
3287
p.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE, mCameraProperties->get(CameraProperties::SUPPORTED_WHITE_BALANCE));
3288
p.set(CameraParameters::KEY_SUPPORTED_EFFECTS, mCameraProperties->get(CameraProperties::SUPPORTED_EFFECTS));
3289
p.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES, mCameraProperties->get(CameraProperties::SUPPORTED_SCENE_MODES));
3290
p.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, mCameraProperties->get(CameraProperties::SUPPORTED_FLASH_MODES));
3291
p.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES, mCameraProperties->get(CameraProperties::SUPPORTED_FOCUS_MODES));
3292
p.set(CameraParameters::KEY_SUPPORTED_ANTIBANDING, mCameraProperties->get(CameraProperties::SUPPORTED_ANTIBANDING));
3293
p.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION, mCameraProperties->get(CameraProperties::SUPPORTED_EV_MAX));
3294
p.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION, mCameraProperties->get(CameraProperties::SUPPORTED_EV_MIN));
3295
p.set(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP, mCameraProperties->get(CameraProperties::SUPPORTED_EV_STEP));
3296
p.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES, mCameraProperties->get(CameraProperties::SUPPORTED_SCENE_MODES));
3297
p.set(TICameraParameters::KEY_SUPPORTED_EXPOSURE, mCameraProperties->get(CameraProperties::SUPPORTED_EXPOSURE_MODES));
3298
p.set(TICameraParameters::KEY_SUPPORTED_ISO_VALUES, mCameraProperties->get(CameraProperties::SUPPORTED_ISO_VALUES));
3299
p.set(CameraParameters::KEY_ZOOM_RATIOS, mCameraProperties->get(CameraProperties::SUPPORTED_ZOOM_RATIOS));
3300
p.set(CameraParameters::KEY_MAX_ZOOM, mCameraProperties->get(CameraProperties::SUPPORTED_ZOOM_STAGES));
3301
p.set(CameraParameters::KEY_ZOOM_SUPPORTED, mCameraProperties->get(CameraProperties::ZOOM_SUPPORTED));
3302
p.set(CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED, mCameraProperties->get(CameraProperties::SMOOTH_ZOOM_SUPPORTED));
3303
p.set(TICameraParameters::KEY_SUPPORTED_IPP, mCameraProperties->get(CameraProperties::SUPPORTED_IPP_MODES));
3304
p.set(TICameraParameters::KEY_S3D_SUPPORTED,mCameraProperties->get(CameraProperties::S3D_SUPPORTED));
3305
p.set(TICameraParameters::KEY_S3D2D_PREVIEW_MODE,mCameraProperties->get(CameraProperties::S3D2D_PREVIEW_MODES));
3306
p.set(TICameraParameters::KEY_AUTOCONVERGENCE_MODE, mCameraProperties->get(CameraProperties::AUTOCONVERGENCE_MODE));
3307
p.set(TICameraParameters::KEY_MANUALCONVERGENCE_VALUES, mCameraProperties->get(CameraProperties::MANUALCONVERGENCE_VALUES));
3308
p.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED, mCameraProperties->get(CameraProperties::VSTAB_SUPPORTED));
3309
p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, mCameraProperties->get(CameraProperties::FRAMERATE_RANGE_SUPPORTED));
3310
p.set(TICameraParameters::KEY_SENSOR_ORIENTATION, mCameraProperties->get(CameraProperties::SENSOR_ORIENTATION));
3311
p.set(TICameraParameters::KEY_SENSOR_ORIENTATION_VALUES, mCameraProperties->get(CameraProperties::SENSOR_ORIENTATION_VALUES));
3312
p.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, mCameraProperties->get(CameraProperties::AUTO_EXPOSURE_LOCK_SUPPORTED));
3313
p.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, mCameraProperties->get(CameraProperties::AUTO_WHITEBALANCE_LOCK_SUPPORTED));
3314
p.set(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED, mCameraProperties->get(CameraProperties::VIDEO_SNAPSHOT_SUPPORTED));
3316
LOG_FUNCTION_NAME_EXIT;
3320
void CameraHal::initDefaultParameters()
3322
//Purpose of this function is to initialize the default current and supported parameters for the currently
3325
CameraParameters &p = mParameters;
3326
int currentRevision, adapterRevision;
3327
status_t ret = NO_ERROR;
3332
ret = parseResolution(mCameraProperties->get(CameraProperties::PREVIEW_SIZE), width, height);
3334
if ( NO_ERROR == ret )
3336
p.setPreviewSize(width, height);
3340
p.setPreviewSize(MIN_WIDTH, MIN_HEIGHT);
3343
ret = parseResolution(mCameraProperties->get(CameraProperties::PICTURE_SIZE), width, height);
3345
if ( NO_ERROR == ret )
3347
p.setPictureSize(width, height);
3351
p.setPictureSize(PICTURE_WIDTH, PICTURE_HEIGHT);
3354
ret = parseResolution(mCameraProperties->get(CameraProperties::JPEG_THUMBNAIL_SIZE), width, height);
3356
if ( NO_ERROR == ret )
3358
p.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, width);
3359
p.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, height);
3363
p.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, MIN_WIDTH);
3364
p.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, MIN_HEIGHT);
3367
insertSupportedParams();
3369
//Insert default values
3370
p.setPreviewFrameRate(atoi(mCameraProperties->get(CameraProperties::PREVIEW_FRAME_RATE)));
3371
p.setPreviewFormat(mCameraProperties->get(CameraProperties::PREVIEW_FORMAT));
3372
p.setPictureFormat(mCameraProperties->get(CameraProperties::PICTURE_FORMAT));
3373
p.set(CameraParameters::KEY_JPEG_QUALITY, mCameraProperties->get(CameraProperties::JPEG_QUALITY));
3374
p.set(CameraParameters::KEY_WHITE_BALANCE, mCameraProperties->get(CameraProperties::WHITEBALANCE));
3375
p.set(CameraParameters::KEY_EFFECT, mCameraProperties->get(CameraProperties::EFFECT));
3376
p.set(CameraParameters::KEY_ANTIBANDING, mCameraProperties->get(CameraProperties::ANTIBANDING));
3377
p.set(CameraParameters::KEY_FLASH_MODE, mCameraProperties->get(CameraProperties::FLASH_MODE));
3378
p.set(CameraParameters::KEY_FOCUS_MODE, mCameraProperties->get(CameraProperties::FOCUS_MODE));
3379
p.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, mCameraProperties->get(CameraProperties::EV_COMPENSATION));
3380
p.set(CameraParameters::KEY_SCENE_MODE, mCameraProperties->get(CameraProperties::SCENE_MODE));
3381
p.set(CameraParameters::KEY_FLASH_MODE, mCameraProperties->get(CameraProperties::FLASH_MODE));
3382
p.set(CameraParameters::KEY_ZOOM, mCameraProperties->get(CameraProperties::ZOOM));
3383
p.set(TICameraParameters::KEY_CONTRAST, mCameraProperties->get(CameraProperties::CONTRAST));
3384
p.set(TICameraParameters::KEY_SATURATION, mCameraProperties->get(CameraProperties::SATURATION));
3385
p.set(TICameraParameters::KEY_BRIGHTNESS, mCameraProperties->get(CameraProperties::BRIGHTNESS));
3386
p.set(TICameraParameters::KEY_SHARPNESS, mCameraProperties->get(CameraProperties::SHARPNESS));
3387
p.set(TICameraParameters::KEY_EXPOSURE_MODE, mCameraProperties->get(CameraProperties::EXPOSURE_MODE));
3388
p.set(TICameraParameters::KEY_ISO, mCameraProperties->get(CameraProperties::ISO_MODE));
3389
p.set(TICameraParameters::KEY_IPP, mCameraProperties->get(CameraProperties::IPP));
3390
p.set(TICameraParameters::KEY_GBCE, mCameraProperties->get(CameraProperties::GBCE));
3391
p.set(TICameraParameters::KEY_S3D2D_PREVIEW, mCameraProperties->get(CameraProperties::S3D2D_PREVIEW));
3392
p.set(TICameraParameters::KEY_AUTOCONVERGENCE, mCameraProperties->get(CameraProperties::AUTOCONVERGENCE));
3393
p.set(TICameraParameters::KEY_MANUALCONVERGENCE_VALUES, mCameraProperties->get(CameraProperties::MANUALCONVERGENCE_VALUES));
3394
p.set(CameraParameters::KEY_VIDEO_STABILIZATION, mCameraProperties->get(CameraProperties::VSTAB));
3395
p.set(CameraParameters::KEY_FOCAL_LENGTH, mCameraProperties->get(CameraProperties::FOCAL_LENGTH));
3396
p.set(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, mCameraProperties->get(CameraProperties::HOR_ANGLE));
3397
p.set(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, mCameraProperties->get(CameraProperties::VER_ANGLE));
3398
p.set(CameraParameters::KEY_PREVIEW_FPS_RANGE,mCameraProperties->get(CameraProperties::FRAMERATE_RANGE));
3399
p.set(TICameraParameters::KEY_SENSOR_ORIENTATION, mCameraProperties->get(CameraProperties::SENSOR_ORIENTATION));
3400
p.set(TICameraParameters::KEY_SENSOR_ORIENTATION_VALUES, mCameraProperties->get(CameraProperties::SENSOR_ORIENTATION_VALUES));
3401
p.set(TICameraParameters::KEY_EXIF_MAKE, mCameraProperties->get(CameraProperties::EXIF_MAKE));
3402
p.set(TICameraParameters::KEY_EXIF_MODEL, mCameraProperties->get(CameraProperties::EXIF_MODEL));
3403
p.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, mCameraProperties->get(CameraProperties::JPEG_THUMBNAIL_QUALITY));
3404
p.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT, "OMX_TI_COLOR_FormatYUV420PackedSemiPlanar");
3405
p.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW, mCameraProperties->get(CameraProperties::MAX_FD_HW_FACES));
3406
p.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW, mCameraProperties->get(CameraProperties::MAX_FD_SW_FACES));
3408
// Only one area a.k.a Touch AF for now.
3409
// TODO: Add support for multiple focus areas.
3410
p.set(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS, mCameraProperties->get(CameraProperties::MAX_FOCUS_AREAS));
3411
p.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, mCameraProperties->get(CameraProperties::AUTO_EXPOSURE_LOCK));
3412
p.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, mCameraProperties->get(CameraProperties::AUTO_WHITEBALANCE_LOCK));
3413
p.set(CameraParameters::KEY_MAX_NUM_METERING_AREAS, mCameraProperties->get(CameraProperties::MAX_NUM_METERING_AREAS));
3415
LOG_FUNCTION_NAME_EXIT;
3419
@brief Stop a previously started preview.
3424
void CameraHal::forceStopPreview()
3428
// stop bracketing if it is running
3429
stopImageBracketing();
3431
if(mDisplayAdapter.get() != NULL) {
3432
///Stop the buffer display first
3433
mDisplayAdapter->disableDisplay();
3436
if(mAppCallbackNotifier.get() != NULL) {
3437
//Stop the callback sending
3438
mAppCallbackNotifier->stop();
3439
mAppCallbackNotifier->flushAndReturnFrames();
3440
mAppCallbackNotifier->stopPreviewCallbacks();
3443
if ( NULL != mCameraAdapter ) {
3444
// only need to send these control commands to state machine if we are
3445
// passed the LOADED_PREVIEW_STATE
3446
if (mCameraAdapter->getState() > CameraAdapter::LOADED_PREVIEW_STATE) {
3447
// according to javadoc...FD should be stopped in stopPreview
3448
// and application needs to call startFaceDection again
3450
mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_FD);
3453
mCameraAdapter->rollbackToInitializedState();
3458
freePreviewDataBufs();
3460
mPreviewEnabled = false;
3461
mDisplayPaused = false;
3462
mPreviewStartInProgress = false;
3464
LOG_FUNCTION_NAME_EXIT;
3468
@brief Deallocates memory for all the resources held by Camera HAL.
3470
Frees the following objects- CameraAdapter, AppCallbackNotifier, DisplayAdapter,
3477
void CameraHal::deinitialize()
3481
if ( mPreviewEnabled || mDisplayPaused ) {
3485
mSetPreviewWindowCalled = false;
3487
if (mSensorListener.get()) {
3488
mSensorListener->disableSensor(SensorListener::SENSOR_ORIENTATION);
3489
mSensorListener.clear();
3490
mSensorListener = NULL;
3493
LOG_FUNCTION_NAME_EXIT;
3497
status_t CameraHal::storeMetaDataInBuffers(bool enable)
3501
return mAppCallbackNotifier->useMetaDataBufferMode(enable);
3503
LOG_FUNCTION_NAME_EXIT;
3506
void CameraHal::selectFPSRange(int framerate, int *min_fps, int *max_fps)
3509
char supported[MAX_PROP_VALUE_LENGTH];
3510
int fpsrangeArray[2];
3514
size_t size = strlen(mCameraProperties->get(CameraProperties::FRAMERATE_RANGE_SUPPORTED))+1;
3515
strncpy(supported, mCameraProperties->get(CameraProperties::FRAMERATE_RANGE_SUPPORTED), size);
3517
ptr = strtok (supported," (,)");
3521
fpsrangeArray[i]= atoi(ptr)/CameraHal::VFR_SCALE;
3524
if (framerate == fpsrangeArray[i])
3526
CAMHAL_LOGDB("SETTING FPS RANGE min = %d max = %d \n", fpsrangeArray[0], fpsrangeArray[1]);
3527
*min_fps = fpsrangeArray[0]*CameraHal::VFR_SCALE;
3528
*max_fps = fpsrangeArray[1]*CameraHal::VFR_SCALE;
3532
ptr = strtok (NULL, " (,)");
3537
LOG_FUNCTION_NAME_EXIT;
3541
void CameraHal::setPreferredPreviewRes(int width, int height)
3545
if ( (width == 320) && (height == 240)){
3546
mParameters.setPreviewSize(640,480);
3548
if ( (width == 176) && (height == 144)){
3549
mParameters.setPreviewSize(704,576);
3552
LOG_FUNCTION_NAME_EXIT;
3555
void CameraHal::resetPreviewRes(CameraParameters *mParams, int width, int height)
3559
if ( (width <= 320) && (height <= 240)){
3560
mParams->setPreviewSize(mVideoWidth, mVideoHeight);
3563
LOG_FUNCTION_NAME_EXIT;
added
removed
android/hardware/ti/omap4xxx/camera/CameraHal.cpp
