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

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