path: root/CameraHal.cpp (plain)
blob: f739a776c831106c90c0cf92fd3156f7ca90889e

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