path: root/CameraHal.cpp (plain)
blob: 284cb36104a7cb19ccea6e980a0d3d3c052c73e6

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	ret = GrallocAlloc.alloc(width, height, HAL_PIXEL_FORMAT_NV12, CAMHAL_GRALLOC_USAGE, &buf, &stride);
1439	if (ret != NO_ERROR){
1440	CAMHAL_LOGEA("Couldn't allocate video buffers using Gralloc");
1441	ret = -NO_MEMORY;
1442	for (uint32_t j=0; j< i; j++){
1443	buf = (buffer_handle_t)bufsArr[j];
1444	CAMHAL_LOGEB("Freeing Gralloc Buffer 0x%x", (uint32_t)buf);
1445	GrallocAlloc.free(buf);
1446	}
1447	delete [] bufsArr;
1448	goto exit;
1449	}
1450	bufsArr[i] = buf;
1451	CAMHAL_LOGVB("*** Gralloc Handle =0x%x ***", (uint32_t)buf);
1452	}
1453
1454	mVideoBufs = (int32_t *)bufsArr;
1455	}
1456	else{
1457	CAMHAL_LOGEA("Couldn't allocate video buffers ");
1458	ret = -NO_MEMORY;
1459	}
1460	}
1461
1462	exit:
1463	LOG_FUNCTION_NAME;
1464
1465	return ret;
1466	}
1467
1468	void endImageCapture( void *userData)
1469	{
1470	LOG_FUNCTION_NAME;
1471
1472	if ( NULL != userData )
1473	{
1474	CameraHal *c = reinterpret_cast<CameraHal *>(userData);
1475	c->signalEndImageCapture();
1476	}
1477
1478	LOG_FUNCTION_NAME_EXIT;
1479	}
1480
1481	void releaseImageBuffers(void *userData)
1482	{
1483	LOG_FUNCTION_NAME;
1484
1485	if (NULL != userData) {
1486	CameraHal *c = reinterpret_cast<CameraHal *>(userData);
1487	c->freeImageBufs();
1488	}
1489
1490	LOG_FUNCTION_NAME_EXIT;
1491	}
1492
1493	status_t CameraHal::signalEndImageCapture()
1494	{
1495	status_t ret = NO_ERROR;
1496	int w,h;
1497	CameraParameters adapterParams = mParameters;
1498	Mutex::Autolock lock(mLock);
1499
1500	LOG_FUNCTION_NAME;
1501
1502	if ( mBracketingRunning ) {
1503	stopImageBracketing();
1504	} else {
1505	mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_IMAGE_CAPTURE);
1506	}
1507
1508	LOG_FUNCTION_NAME_EXIT;
1509
1510	return ret;
1511	}
1512
1513	status_t CameraHal::freeImageBufs()
1514	{
1515	status_t ret = NO_ERROR;
1516
1517	LOG_FUNCTION_NAME;
1518
1519	if ( NO_ERROR == ret )
1520	{
1521
1522	if( NULL != mImageBufs )
1523	{
1524
1525	///@todo Pluralise the name of this method to freeBuffers
1526	ret = mMemoryManager->freeBuffer(mImageBufs);
1527	mImageBufs = NULL;
1528
1529	}
1530	else
1531	{
1532	ret = -EINVAL;
1533	}
1534
1535	}
1536
1537	LOG_FUNCTION_NAME_EXIT;
1538
1539	return ret;
1540	}
1541
1542	status_t CameraHal::freeVideoBufs(void *bufs)
1543	{
1544	status_t ret = NO_ERROR;
1545
1546	LOG_FUNCTION_NAME;
1547
1548	buffer_handle_t *pBuf = (buffer_handle_t*)bufs;
1549	int count = atoi(mCameraProperties->get(CameraProperties::REQUIRED_PREVIEW_BUFS));
1550	if(pBuf == NULL)
1551	{
1552	CAMHAL_LOGEA("NULL pointer passed to freeVideoBuffer");
1553	LOG_FUNCTION_NAME_EXIT;
1554	return BAD_VALUE;
1555	}
1556
1557	GraphicBufferAllocator &GrallocAlloc = GraphicBufferAllocator::get();
1558
1559	for(int i = 0; i < count; i++){
1560	buffer_handle_t ptr = *pBuf++;
1561	CAMHAL_LOGVB("Free Video Gralloc Handle 0x%x", (uint32_t)ptr);
1562	GrallocAlloc.free(ptr);
1563	}
1564
1565	LOG_FUNCTION_NAME_EXIT;
1566
1567	return ret;
1568	}
1569
1570	/**
1571	@brief Start preview mode.
1572
1573	@param none
1574	@return NO_ERROR Camera switched to VF mode
1575	@todo Update function header with the different errors that are possible
1576
1577	*/
1578	status_t CameraHal::startPreview()
1579	{
1580	status_t ret = NO_ERROR;
1581	CameraAdapter::BuffersDescriptor desc;
1582	CameraFrame frame;
1583	const char *valstr = NULL;
1584	unsigned int required_buffer_count;
1585	unsigned int max_queueble_buffers;
1586
1587	#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
1588	gettimeofday(&mStartPreview, NULL);
1589	#endif
1590
1591	LOG_FUNCTION_NAME;
1592
1593	refCount ++;
1594	if ( mPreviewEnabled ){
1595	CAMHAL_LOGDA("Preview already running");
1596	LOG_FUNCTION_NAME_EXIT;
1597	return ALREADY_EXISTS;
1598	}
1599
1600	if ( NULL != mCameraAdapter ) {
1601	ret = mCameraAdapter->setParameters(mParameters);
1602	}
1603
1604	if ((mPreviewStartInProgress == false) && (mDisplayPaused == false)){
1605	ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_RESOLUTION_PREVIEW,( int ) &frame);
1606	if ( NO_ERROR != ret ){
1607	CAMHAL_LOGEB("Error: CAMERA_QUERY_RESOLUTION_PREVIEW %d", ret);
1608	return ret;
1609	}
1610
1611	///Update the current preview width and height
1612	mPreviewWidth = frame.mWidth;
1613	mPreviewHeight = frame.mHeight;
1614	//Update the padded width and height - required for VNF and VSTAB
1615	mParameters.set(ExCameraParameters::KEY_PADDED_WIDTH, mPreviewWidth);
1616	mParameters.set(ExCameraParameters::KEY_PADDED_HEIGHT, mPreviewHeight);
1617
1618	}
1619
1620	///If we don't have the preview callback enabled and display adapter,
1621	if(!mSetPreviewWindowCalled || (mDisplayAdapter.get() == NULL)){
1622	CAMHAL_LOGEA("Preview not started. Preview in progress flag set");
1623	mPreviewStartInProgress = true;
1624	ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_SWITCH_TO_EXECUTING);
1625	if ( NO_ERROR != ret ){
1626	CAMHAL_LOGEB("Error: CAMERA_SWITCH_TO_EXECUTING %d", ret);
1627	return ret;
1628	}
1629	return NO_ERROR;
1630	}
1631
1632	if( (mDisplayAdapter.get() != NULL) && ( !mPreviewEnabled ) && ( mDisplayPaused ) )
1633	{
1634	CAMHAL_LOGDA("Preview is in paused state");
1635
1636	mDisplayPaused = false;
1637	mPreviewEnabled = true;
1638	if ( NO_ERROR == ret )
1639	{
1640	ret = mDisplayAdapter->pauseDisplay(mDisplayPaused);
1641	if ( NO_ERROR != ret )
1642	{
1643	CAMHAL_LOGEB("Display adapter resume failed %x", ret);
1644	}
1645	}
1646	//restart preview callbacks
1647	if(mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME)
1648	{
1649	mAppCallbackNotifier->enableMsgType (CAMERA_MSG_PREVIEW_FRAME);
1650	}
1651	return ret;
1652	}
1653	required_buffer_count = atoi(mCameraProperties->get(CameraProperties::REQUIRED_PREVIEW_BUFS));
1654
1655	///Allocate the preview buffers
1656	ret = allocPreviewBufs(mPreviewWidth, mPreviewHeight, mParameters.getPreviewFormat(), required_buffer_count, max_queueble_buffers);
1657
1658	if ( NO_ERROR != ret )
1659	{
1660	CAMHAL_LOGEA("Couldn't allocate buffers for Preview");
1661	goto error;
1662	}
1663
1664	if ( mMeasurementEnabled )
1665	{
1666	ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_PREVIEW_DATA,
1667	( int ) &frame,
1668	required_buffer_count);
1669	if ( NO_ERROR != ret )
1670	{
1671	return ret;
1672	}
1673
1674	///Allocate the preview data buffers
1675	ret = allocPreviewDataBufs(frame.mLength, required_buffer_count);
1676	if ( NO_ERROR != ret ) {
1677	CAMHAL_LOGEA("Couldn't allocate preview data buffers");
1678	goto error;
1679	}
1680
1681	if ( NO_ERROR == ret )
1682	{
1683	desc.mBuffers = mPreviewDataBufs;
1684	desc.mOffsets = mPreviewDataOffsets;
1685	desc.mFd = mPreviewDataFd;
1686	desc.mLength = mPreviewDataLength;
1687	desc.mCount = ( size_t ) required_buffer_count;
1688	desc.mMaxQueueable = (size_t) required_buffer_count;
1689	mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_PREVIEW_DATA,
1690	( int ) &desc);
1691	}
1692	}
1693
1694	///Pass the buffers to Camera Adapter
1695	desc.mBuffers = mPreviewBufs;
1696	desc.mOffsets = mPreviewOffsets;
1697	desc.mFd = mPreviewFd;
1698	desc.mLength = mPreviewLength;
1699	desc.mCount = ( size_t ) required_buffer_count;
1700	desc.mMaxQueueable = (size_t) max_queueble_buffers;
1701
1702	ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_PREVIEW,
1703	( int ) &desc);
1704
1705	if ( NO_ERROR != ret )
1706	{
1707	CAMHAL_LOGEB("Failed to register preview buffers: 0x%x", ret);
1708	freePreviewBufs();
1709	return ret;
1710	}
1711
1712	mAppCallbackNotifier->startPreviewCallbacks(mParameters, mPreviewBufs, mPreviewOffsets, mPreviewFd, mPreviewLength, required_buffer_count);
1713
1714	///Start the callback notifier
1715	ret = mAppCallbackNotifier->start();
1716
1717	if( ALREADY_EXISTS == ret )
1718	{
1719	//Already running, do nothing
1720	CAMHAL_LOGDA("AppCallbackNotifier already running");
1721	ret = NO_ERROR;
1722	}
1723	else if ( NO_ERROR == ret ) {
1724	CAMHAL_LOGDA("Started AppCallbackNotifier..");
1725	mAppCallbackNotifier->setMeasurements(mMeasurementEnabled);
1726	}
1727	else
1728	{
1729	CAMHAL_LOGDA("Couldn't start AppCallbackNotifier");
1730	goto error;
1731	}
1732
1733	///Enable the display adapter if present, actual overlay enable happens when we post the buffer
1734	if(mDisplayAdapter.get() != NULL)
1735	{
1736	CAMHAL_LOGDA("Enabling display");
1737	bool isS3d = false;
1738	DisplayAdapter::S3DParameters s3dParams;
1739	int width, height;
1740	mParameters.getPreviewSize(&width, &height);
1741	#if 0 //TODO: s3d is not part of bringup...will reenable
1742	if ( (valstr = mParameters.get(ExCameraParameters::KEY_S3D_SUPPORTED)) != NULL) {
1743	isS3d = (strcmp(valstr, "true") == 0);
1744	}
1745	if ( (valstr = mParameters.get(ExCameraParameters::KEY_S3D2D_PREVIEW)) != NULL) {
1746	if (strcmp(valstr, "off") == 0)
1747	{
1748	CAMHAL_LOGEA("STEREO 3D->2D PREVIEW MODE IS OFF");
1749	//TODO: obtain the frame packing configuration from camera or user settings
1750	//once side by side configuration is supported
1751	s3dParams.mode = OVERLAY_S3D_MODE_ON;
1752	s3dParams.framePacking = OVERLAY_S3D_FORMAT_OVERUNDER;
1753	s3dParams.order = OVERLAY_S3D_ORDER_LF;
1754	s3dParams.subSampling = OVERLAY_S3D_SS_NONE;
1755	}
1756	else
1757	{
1758	CAMHAL_LOGEA("STEREO 3D->2D PREVIEW MODE IS ON");
1759	s3dParams.mode = OVERLAY_S3D_MODE_OFF;
1760	s3dParams.framePacking = OVERLAY_S3D_FORMAT_OVERUNDER;
1761	s3dParams.order = OVERLAY_S3D_ORDER_LF;
1762	s3dParams.subSampling = OVERLAY_S3D_SS_NONE;
1763	}
1764	}
1765	#endif //if 0
1766
1767	#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
1768
1769	ret = mDisplayAdapter->enableDisplay(width, height, &mStartPreview, isS3d ? &s3dParams : NULL);
1770	#else
1771	ret = mDisplayAdapter->enableDisplay(width, height, NULL, isS3d ? &s3dParams : NULL);
1772	#endif
1773	if ( ret != NO_ERROR )
1774	{
1775	CAMHAL_LOGEA("Couldn't enable display");
1776	goto error;
1777	}
1778	}
1779
1780	///Send START_PREVIEW command to adapter
1781	CAMHAL_LOGDA("Starting CameraAdapter preview mode");
1782	ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_PREVIEW);
1783	if(ret!=NO_ERROR)
1784	{
1785	CAMHAL_LOGEA("Couldn't start preview w/ CameraAdapter");
1786	goto error;
1787	}
1788	CAMHAL_LOGDA("Started preview");
1789
1790	mPreviewEnabled = true;
1791	mPreviewStartInProgress = false;
1792	return ret;
1793
1794	error:
1795	CAMHAL_LOGEA("Performing cleanup after error");
1796	//Do all the cleanup
1797	freePreviewBufs();
1798	mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_PREVIEW);
1799	if(mDisplayAdapter.get() != NULL)
1800	{
1801	mDisplayAdapter->disableDisplay(false);
1802	}
1803	mAppCallbackNotifier->stop();
1804	mPreviewStartInProgress = false;
1805	mPreviewEnabled = false;
1806	LOG_FUNCTION_NAME_EXIT;
1807	return ret;
1808	}
1809
1810	/**
1811	@brief Sets ANativeWindow object.
1812
1813	Preview buffers provided to CameraHal via this object. DisplayAdapter will be interfacing with it
1814	to render buffers to display.
1815
1816	@param[in] window The ANativeWindow object created by Surface flinger
1817	@return NO_ERROR If the ANativeWindow object passes validation criteria
1818	@todo Define validation criteria for ANativeWindow object. Define error codes for scenarios
1819
1820	*/
1821	status_t CameraHal::setPreviewWindow(struct preview_stream_ops *window)
1822	{
1823	status_t ret = NO_ERROR;
1824	CameraAdapter::BuffersDescriptor desc;
1825
1826	LOG_FUNCTION_NAME;
1827	mSetPreviewWindowCalled = true;
1828
1829	///If the Camera service passes a null window, we destroy existing window and free the DisplayAdapter
1830	if(!window)
1831	{
1832	if(mDisplayAdapter.get() != NULL)
1833	{
1834	///NULL window passed, destroy the display adapter if present
1835	CAMHAL_LOGEA("NULL window passed, destroying display adapter");
1836	mDisplayAdapter.clear();
1837	///@remarks If there was a window previously existing, we usually expect another valid window to be passed by the client
1838	///@remarks so, we will wait until it passes a valid window to begin the preview again
1839	mSetPreviewWindowCalled = false;
1840	}
1841	CAMHAL_LOGEA("NULL ANativeWindow passed to setPreviewWindow");
1842	return NO_ERROR;
1843	}else if(mDisplayAdapter.get() == NULL)
1844	{
1845	// Need to create the display adapter since it has not been created
1846	// Create display adapter
1847	mDisplayAdapter = new ANativeWindowDisplayAdapter();
1848	ret = NO_ERROR;
1849	if(!mDisplayAdapter.get() || ((ret=mDisplayAdapter->initialize())!=NO_ERROR))
1850	{
1851	if(ret!=NO_ERROR)
1852	{
1853	mDisplayAdapter.clear();
1854	CAMHAL_LOGEA("DisplayAdapter initialize failed");
1855	LOG_FUNCTION_NAME_EXIT;
1856	return ret;
1857	}
1858	else
1859	{
1860	CAMHAL_LOGEA("Couldn't create DisplayAdapter");
1861	LOG_FUNCTION_NAME_EXIT;
1862	return NO_MEMORY;
1863	}
1864	}
1865
1866	// DisplayAdapter needs to know where to get the CameraFrames from inorder to display
1867	// Since CameraAdapter is the one that provides the frames, set it as the frame provider for DisplayAdapter
1868	mDisplayAdapter->setFrameProvider(mCameraAdapter);
1869
1870	// Any dynamic errors that happen during the camera use case has to be propagated back to the application
1871	// via CAMERA_MSG_ERROR. AppCallbackNotifier is the class that notifies such errors to the application
1872	// Set it as the error handler for the DisplayAdapter
1873	mDisplayAdapter->setErrorHandler(mAppCallbackNotifier.get());
1874
1875	// Update the display adapter with the new window that is passed from CameraService
1876	ret = mDisplayAdapter->setPreviewWindow(window);
1877	if(ret!=NO_ERROR)
1878	{
1879	CAMHAL_LOGEB("DisplayAdapter setPreviewWindow returned error %d", ret);
1880	}
1881
1882	if(mPreviewStartInProgress)
1883	{
1884	CAMHAL_LOGDA("setPreviewWindow called when preview running");
1885	// Start the preview since the window is now available
1886	ret = startPreview();
1887	}
1888	}else
1889	{
1890	/* If mDisplayAdpater is already created. No need to do anything.
1891	* We get a surface handle directly now, so we can reconfigure surface
1892	* itself in DisplayAdapter if dimensions have changed
1893	*/
1894	}
1895	LOG_FUNCTION_NAME_EXIT;
1896
1897	return ret;
1898
1899	}
1900
1901
1902	/**
1903	@brief Stop a previously started preview.
1904
1905	@param none
1906	@return none
1907
1908	*/
1909	void CameraHal::stopPreview()
1910	{
1911	LOG_FUNCTION_NAME;
1912
1913	refCount --;
1914	if( (!previewEnabled() && !mDisplayPaused) || mRecordingEnabled)
1915	{
1916	CAMHAL_LOGDA("direct return1\n");
1917	return;
1918	}
1919
1920	bool imageCaptureRunning = (mCameraAdapter->getState() == CameraAdapter::CAPTURE_STATE) &&
1921	(mCameraAdapter->getNextState() != CameraAdapter::PREVIEW_STATE);
1922	if(mDisplayPaused && !imageCaptureRunning && (refCount>=0))
1923	{
1924	// Display is paused, which essentially means there is no preview active.
1925	// Note: this is done so that when stopPreview is called by client after
1926	// an image capture, we do not de-initialize the camera adapter and
1927	// restart over again.
1928	CAMHAL_LOGDA("direct return2\n");
1929	return;
1930	}
1931
1932	forceStopPreview();
1933
1934	// Reset Capture-Mode to default, so that when we switch from VideoRecording
1935	// to ImageCapture, CAPTURE_MODE is not left to VIDEO_MODE.
1936	CAMHAL_LOGDA("Resetting Capture-Mode to default");
1937	mParameters.set(ExCameraParameters::KEY_CAP_MODE, "");
1938
1939	refCount =0;
1940	LOG_FUNCTION_NAME_EXIT;
1941	}
1942
1943	/**
1944	@brief Returns true if preview is enabled
1945
1946	@param none
1947	@return true If preview is running currently
1948	false If preview has been stopped
1949
1950	*/
1951	bool CameraHal::previewEnabled()
1952	{
1953	LOG_FUNCTION_NAME;
1954
1955	return (mPreviewEnabled || mPreviewStartInProgress);
1956	}
1957
1958	/**
1959	@brief Start record mode.
1960
1961	When a record image is available a CAMERA_MSG_VIDEO_FRAME message is sent with
1962	the corresponding frame. Every record frame must be released by calling
1963	releaseRecordingFrame().
1964
1965	@param none
1966	@return NO_ERROR If recording could be started without any issues
1967	@todo Update the header with possible error values in failure scenarios
1968
1969	*/
1970	status_t CameraHal::startRecording( )
1971	{
1972	int w, h;
1973	const char *valstr = NULL;
1974	bool restartPreviewRequired = false;
1975	status_t ret = NO_ERROR;
1976
1977	LOG_FUNCTION_NAME;
1978
1979	#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
1980	gettimeofday(&mStartPreview, NULL);
1981	#endif
1982
1983	if(!previewEnabled())
1984	{
1985	return NO_INIT;
1986	}
1987
1988	// set internal recording hint in case camera adapter needs to make some
1989	// decisions....(will only be sent to camera adapter if camera restart is required)
1990	mParameters.set(ExCameraParameters::KEY_RECORDING_HINT, CameraParameters::TRUE);
1991
1992	// if application starts recording in continuous focus picture mode...
1993	// then we need to force default capture mode (as opposed to video mode)
1994	if ( ((valstr = mParameters.get(CameraParameters::KEY_FOCUS_MODE)) != NULL) &&
1995	(strcmp(valstr, CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE) == 0) ){
1996	restartPreviewRequired = resetVideoModeParameters();
1997	}
1998
1999	// only need to check recording hint if preview restart is not already needed
2000	valstr = mParameters.get(CameraParameters::KEY_RECORDING_HINT);
2001	if ( !restartPreviewRequired &&
2002	(!valstr || (valstr && (strcmp(valstr, CameraParameters::TRUE) != 0))) ) {
2003	restartPreviewRequired = setVideoModeParameters(mParameters);
2004	}
2005
2006	if (restartPreviewRequired) {
2007	ret = restartPreview();
2008	}
2009
2010	if ( NO_ERROR == ret )
2011	{
2012	int count = atoi(mCameraProperties->get(CameraProperties::REQUIRED_PREVIEW_BUFS));
2013	mParameters.getPreviewSize(&w, &h);
2014	CAMHAL_LOGDB("%s Video Width=%d Height=%d", __FUNCTION__, mVideoWidth, mVideoHeight);
2015
2016	if ((w != mVideoWidth) && (h != mVideoHeight))
2017	{
2018	ret = allocVideoBufs(mVideoWidth, mVideoHeight, count);
2019	if ( NO_ERROR != ret )
2020	{
2021	CAMHAL_LOGEB("allocVideoBufs returned error 0x%x", ret);
2022	mParameters.remove(ExCameraParameters::KEY_RECORDING_HINT);
2023	return ret;
2024	}
2025
2026	mAppCallbackNotifier->useVideoBuffers(true);
2027	mAppCallbackNotifier->setVideoRes(mVideoWidth, mVideoHeight);
2028	ret = mAppCallbackNotifier->initSharedVideoBuffers(mPreviewBufs, mPreviewOffsets, mPreviewFd, mPreviewLength, count, mVideoBufs);
2029	}
2030	else
2031	{
2032	mAppCallbackNotifier->useVideoBuffers(false);
2033	mAppCallbackNotifier->setVideoRes(mPreviewWidth, mPreviewHeight);
2034	ret = mAppCallbackNotifier->initSharedVideoBuffers(mPreviewBufs, mPreviewOffsets, mPreviewFd, mPreviewLength, count, NULL);
2035	}
2036	}
2037
2038	if ( NO_ERROR == ret )
2039	{
2040	ret = mAppCallbackNotifier->startRecording();
2041	}
2042
2043	if ( NO_ERROR == ret )
2044	{
2045	///Buffers for video capture (if different from preview) are expected to be allocated within CameraAdapter
2046	ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_VIDEO);
2047	}
2048
2049	if ( NO_ERROR == ret )
2050	{
2051	mRecordingEnabled = true;
2052	}
2053
2054	LOG_FUNCTION_NAME_EXIT;
2055
2056	return ret;
2057	}
2058
2059	/**
2060	@brief Set the camera parameters specific to Video Recording.
2061
2062	This function checks for the camera parameters which have to be set for recording.
2063	Video Recording needs CAPTURE_MODE to be VIDEO_MODE. This function sets it.
2064	This function also enables Video Recording specific functions like VSTAB & VNF.
2065
2066	@param none
2067	@return true if preview needs to be restarted for VIDEO_MODE parameters to take effect.
2068	@todo Modify the policies for enabling VSTAB & VNF usecase based later.
2069
2070	*/
2071	bool CameraHal::setVideoModeParameters(const CameraParameters& params)
2072	{
2073	const char *valstr = NULL;
2074	bool restartPreviewRequired = false;
2075	status_t ret = NO_ERROR;
2076
2077	LOG_FUNCTION_NAME;
2078
2079	// Set CAPTURE_MODE to VIDEO_MODE, if not set already and Restart Preview
2080	valstr = mParameters.get(ExCameraParameters::KEY_CAP_MODE);
2081	if ( (valstr == NULL) ||
2082	( (valstr != NULL) && (strcmp(valstr, (const char *) ExCameraParameters::VIDEO_MODE) != 0) ) )
2083	{
2084	CAMHAL_LOGDA("Set CAPTURE_MODE to VIDEO_MODE");
2085	mParameters.set(ExCameraParameters::KEY_CAP_MODE, (const char *) ExCameraParameters::VIDEO_MODE);
2086	restartPreviewRequired = true;
2087	}
2088
2089	// Check if CAPTURE_MODE is VIDEO_MODE, since VSTAB & VNF work only in VIDEO_MODE.
2090	valstr = mParameters.get(ExCameraParameters::KEY_CAP_MODE);
2091	if (strcmp(valstr, (const char *) ExCameraParameters::VIDEO_MODE) == 0) {
2092	// set VSTAB. restart is required if vstab value has changed
2093	if (params.get(CameraParameters::KEY_VIDEO_STABILIZATION) != NULL) {
2094	// make sure we support vstab
2095	if (strcmp(mCameraProperties->get(CameraProperties::VSTAB_SUPPORTED),
2096	CameraParameters::TRUE) == 0) {
2097	valstr = mParameters.get(CameraParameters::KEY_VIDEO_STABILIZATION);
2098	// vstab value has changed
2099	if ((valstr != NULL) &&
2100	strcmp(valstr, params.get(CameraParameters::KEY_VIDEO_STABILIZATION)) != 0) {
2101	restartPreviewRequired = true;
2102	}
2103	mParameters.set(CameraParameters::KEY_VIDEO_STABILIZATION,
2104	params.get(CameraParameters::KEY_VIDEO_STABILIZATION));
2105	}
2106	} else if (mParameters.get(CameraParameters::KEY_VIDEO_STABILIZATION)) {
2107	// vstab was configured but now unset
2108	restartPreviewRequired = true;
2109	mParameters.remove(CameraParameters::KEY_VIDEO_STABILIZATION);
2110	}
2111	}
2112	LOG_FUNCTION_NAME_EXIT;
2113
2114	return restartPreviewRequired;
2115	}
2116
2117	/**
2118	@brief Reset the camera parameters specific to Video Recording.
2119
2120	This function resets CAPTURE_MODE and disables Recording specific functions like VSTAB & VNF.
2121
2122	@param none
2123	@return true if preview needs to be restarted for VIDEO_MODE parameters to take effect.
2124
2125	*/
2126	bool CameraHal::resetVideoModeParameters()
2127	{
2128	const char *valstr = NULL;
2129	bool restartPreviewRequired = false;
2130	status_t ret = NO_ERROR;
2131
2132	LOG_FUNCTION_NAME;
2133
2134	// ignore this if we are already recording
2135	if (mRecordingEnabled) {
2136	return false;
2137	}
2138
2139	// Set CAPTURE_MODE to VIDEO_MODE, if not set already and Restart Preview
2140	valstr = mParameters.get(ExCameraParameters::KEY_CAP_MODE);
2141	if ((valstr != NULL) && (strcmp(valstr, ExCameraParameters::VIDEO_MODE) == 0)) {
2142	CAMHAL_LOGDA("Reset Capture-Mode to default");
2143	mParameters.set(ExCameraParameters::KEY_CAP_MODE, "");
2144	restartPreviewRequired = true;
2145	}
2146
2147	LOG_FUNCTION_NAME_EXIT;
2148
2149	return restartPreviewRequired;
2150	}
2151
2152	/**
2153	@brief Restart the preview with setParameter.
2154
2155	This function restarts preview, for some VIDEO_MODE parameters to take effect.
2156
2157	@param none
2158	@return NO_ERROR If recording parameters could be set without any issues
2159
2160	*/
2161	status_t CameraHal::restartPreview()
2162	{
2163	const char *valstr = NULL;
2164	char tmpvalstr[30];
2165	status_t ret = NO_ERROR;
2166
2167	LOG_FUNCTION_NAME;
2168
2169	// Retain CAPTURE_MODE before calling stopPreview(), since it is reset in stopPreview().
2170	tmpvalstr[0] = 0;
2171	valstr = mParameters.get(ExCameraParameters::KEY_CAP_MODE);
2172	if(valstr != NULL)
2173	{
2174	if(sizeof(tmpvalstr) < (strlen(valstr)+1))
2175	{
2176	return -EINVAL;
2177	}
2178
2179	strncpy(tmpvalstr, valstr, sizeof(tmpvalstr));
2180	tmpvalstr[sizeof(tmpvalstr)-1] = 0;
2181	}
2182
2183	forceStopPreview();
2184
2185	{
2186	Mutex::Autolock lock(mLock);
2187	mParameters.set(ExCameraParameters::KEY_CAP_MODE, tmpvalstr);
2188	mCameraAdapter->setParameters(mParameters);
2189	}
2190
2191	ret = startPreview();
2192
2193	LOG_FUNCTION_NAME_EXIT;
2194
2195	return ret;
2196	}
2197
2198	/**
2199	@brief Stop a previously started recording.
2200
2201	@param none
2202	@return none
2203
2204	*/
2205	void CameraHal::stopRecording()
2206	{
2207	CameraAdapter::AdapterState currentState;
2208
2209	LOG_FUNCTION_NAME;
2210
2211	Mutex::Autolock lock(mLock);
2212
2213	if (!mRecordingEnabled )
2214	{
2215	return;
2216	}
2217
2218	currentState = mCameraAdapter->getState();
2219	if (currentState == CameraAdapter::VIDEO_CAPTURE_STATE) {
2220	mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_IMAGE_CAPTURE);
2221	}
2222
2223	mAppCallbackNotifier->stopRecording();
2224
2225	mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_VIDEO);
2226
2227	mRecordingEnabled = false;
2228
2229	if ( mAppCallbackNotifier->getUseVideoBuffers() ){
2230	freeVideoBufs(mVideoBufs);
2231	if (mVideoBufs){
2232	CAMHAL_LOGVB(" FREEING mVideoBufs 0x%x", (uint32_t)mVideoBufs);
2233	delete [] mVideoBufs;
2234	}
2235	mVideoBufs = NULL;
2236	}
2237
2238	// reset internal recording hint in case camera adapter needs to make some
2239	// decisions....(will only be sent to camera adapter if camera restart is required)
2240	mParameters.remove(ExCameraParameters::KEY_RECORDING_HINT);
2241
2242	LOG_FUNCTION_NAME_EXIT;
2243	}
2244
2245	/**
2246	@brief Returns true if recording is enabled.
2247
2248	@param none
2249	@return true If recording is currently running
2250	false If recording has been stopped
2251
2252	*/
2253	int CameraHal::recordingEnabled()
2254	{
2255	LOG_FUNCTION_NAME;
2256
2257	LOG_FUNCTION_NAME_EXIT;
2258
2259	return mRecordingEnabled;
2260	}
2261
2262	/**
2263	@brief Release a record frame previously returned by CAMERA_MSG_VIDEO_FRAME.
2264
2265	@param[in] mem MemoryBase pointer to the frame being released. Must be one of the buffers
2266	previously given by CameraHal
2267	@return none
2268
2269	*/
2270	void CameraHal::releaseRecordingFrame(const void* mem)
2271	{
2272	LOG_FUNCTION_NAME;
2273
2274	//CAMHAL_LOGDB(" 0x%x", mem->pointer());
2275
2276	if ( ( mRecordingEnabled ) && mem != NULL)
2277	{
2278	mAppCallbackNotifier->releaseRecordingFrame(mem);
2279	}
2280
2281	LOG_FUNCTION_NAME_EXIT;
2282
2283	return;
2284	}
2285
2286	/**
2287	@brief Start auto focus
2288
2289	This call asynchronous.
2290	The notification callback routine is called with CAMERA_MSG_FOCUS once when
2291	focusing is complete. autoFocus() will be called again if another auto focus is
2292	needed.
2293
2294	@param none
2295	@return NO_ERROR
2296	@todo Define the error codes if the focus is not locked
2297
2298	*/
2299	status_t CameraHal::autoFocus()
2300	{
2301	status_t ret = NO_ERROR;
2302
2303	#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
2304
2305	gettimeofday(&mStartFocus, NULL);
2306
2307	#endif
2308
2309
2310	LOG_FUNCTION_NAME;
2311
2312	{
2313	Mutex::Autolock lock(mLock);
2314	mMsgEnabled |= CAMERA_MSG_FOCUS;
2315	}
2316
2317
2318	if ( NULL != mCameraAdapter )
2319	{
2320
2321	#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
2322
2323	//pass the autoFocus timestamp along with the command to camera adapter
2324	ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_PERFORM_AUTOFOCUS, ( int ) &mStartFocus);
2325
2326	#else
2327
2328	ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_PERFORM_AUTOFOCUS);
2329
2330	#endif
2331
2332	}
2333	else
2334	{
2335	ret = -1;
2336	}
2337
2338	LOG_FUNCTION_NAME_EXIT;
2339
2340	return ret;
2341	}
2342
2343	/**
2344	@brief Cancels auto-focus function.
2345
2346	If the auto-focus is still in progress, this function will cancel it.
2347	Whether the auto-focus is in progress or not, this function will return the
2348	focus position to the default. If the camera does not support auto-focus, this is a no-op.
2349
2350
2351	@param none
2352	@return NO_ERROR If the cancel succeeded
2353	@todo Define error codes if cancel didnt succeed
2354
2355	*/
2356	status_t CameraHal::cancelAutoFocus()
2357	{
2358	LOG_FUNCTION_NAME;
2359
2360	Mutex::Autolock lock(mLock);
2361	CameraParameters adapterParams = mParameters;
2362	mMsgEnabled &= ~CAMERA_MSG_FOCUS;
2363
2364	if( NULL != mCameraAdapter )
2365	{
2366	adapterParams.set(ExCameraParameters::KEY_AUTO_FOCUS_LOCK, CameraParameters::FALSE);
2367	mCameraAdapter->setParameters(adapterParams);
2368	mCameraAdapter->sendCommand(CameraAdapter::CAMERA_CANCEL_AUTOFOCUS);
2369	mAppCallbackNotifier->flushEventQueue();
2370	}
2371
2372	LOG_FUNCTION_NAME_EXIT;
2373	return NO_ERROR;
2374	}
2375
2376	void CameraHal::setEventProvider(int32_t eventMask, MessageNotifier * eventNotifier)
2377	{
2378
2379	LOG_FUNCTION_NAME;
2380
2381	if ( NULL != mEventProvider )
2382	{
2383	mEventProvider->disableEventNotification(CameraHalEvent::ALL_EVENTS);
2384	delete mEventProvider;
2385	mEventProvider = NULL;
2386	}
2387
2388	mEventProvider = new EventProvider(eventNotifier, this, eventCallbackRelay);
2389	if ( NULL == mEventProvider )
2390	{
2391	CAMHAL_LOGEA("Error in creating EventProvider");
2392	}
2393	else
2394	{
2395	mEventProvider->enableEventNotification(eventMask);
2396	}
2397
2398	LOG_FUNCTION_NAME_EXIT;
2399	}
2400
2401	void CameraHal::eventCallbackRelay(CameraHalEvent* event)
2402	{
2403	LOG_FUNCTION_NAME;
2404
2405	CameraHal *appcbn = ( CameraHal * ) (event->mCookie);
2406	appcbn->eventCallback(event );
2407
2408	LOG_FUNCTION_NAME_EXIT;
2409	}
2410
2411	void CameraHal::eventCallback(CameraHalEvent* event)
2412	{
2413	LOG_FUNCTION_NAME;
2414
2415	if ( NULL != event )
2416	{
2417	switch( event->mEventType )
2418	{
2419	case CameraHalEvent::EVENT_FOCUS_LOCKED:
2420	case CameraHalEvent::EVENT_FOCUS_ERROR:
2421	{
2422	if ( mBracketingEnabled )
2423	{
2424	startImageBracketing();
2425	}
2426	break;
2427	}
2428	default:
2429	{
2430	break;
2431	}
2432	};
2433	}
2434
2435	LOG_FUNCTION_NAME_EXIT;
2436	}
2437
2438	status_t CameraHal::startImageBracketing()
2439	{
2440	status_t ret = NO_ERROR;
2441	CameraFrame frame;
2442	CameraAdapter::BuffersDescriptor desc;
2443
2444	#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
2445
2446	gettimeofday(&mStartCapture, NULL);
2447
2448	#endif
2449
2450	LOG_FUNCTION_NAME;
2451
2452	if(!previewEnabled() && !mDisplayPaused)
2453	{
2454	LOG_FUNCTION_NAME_EXIT;
2455	return NO_INIT;
2456	}
2457
2458	if ( !mBracketingEnabled )
2459	{
2460	return ret;
2461	}
2462
2463	if ( NO_ERROR == ret )
2464	{
2465	mBracketingRunning = true;
2466	}
2467
2468	if ( (NO_ERROR == ret) && ( NULL != mCameraAdapter ) )
2469	{
2470	ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE,
2471	( int ) &frame,
2472	( mBracketRangeNegative + 1 ));
2473
2474	if ( NO_ERROR != ret )
2475	{
2476	CAMHAL_LOGEB("CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE returned error 0x%x", ret);
2477	}
2478	}
2479
2480	if ( NO_ERROR == ret )
2481	{
2482	if ( NULL != mAppCallbackNotifier.get() )
2483	{
2484	mAppCallbackNotifier->setBurst(true);
2485	}
2486	}
2487
2488	if ( NO_ERROR == ret )
2489	{
2490	mParameters.getPictureSize(( int * ) &frame.mWidth,
2491	( int * ) &frame.mHeight);
2492
2493	ret = allocImageBufs(frame.mWidth,
2494	frame.mHeight,
2495	frame.mLength,
2496	mParameters.getPictureFormat(),
2497	( mBracketRangeNegative + 1 ));
2498	if ( NO_ERROR != ret )
2499	{
2500	CAMHAL_LOGEB("allocImageBufs returned error 0x%x", ret);
2501	}
2502	}
2503
2504	if ( (NO_ERROR == ret) && ( NULL != mCameraAdapter ) )
2505	{
2506
2507	desc.mBuffers = mImageBufs;
2508	desc.mOffsets = mImageOffsets;
2509	desc.mFd = mImageFd;
2510	desc.mLength = mImageLength;
2511	desc.mCount = ( size_t ) ( mBracketRangeNegative + 1 );
2512	desc.mMaxQueueable = ( size_t ) ( mBracketRangeNegative + 1 );
2513
2514	ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_IMAGE_CAPTURE,
2515	( int ) &desc);
2516
2517	if ( NO_ERROR == ret )
2518	{
2519
2520	#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
2521
2522	//pass capture timestamp along with the camera adapter command
2523	ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_BRACKET_CAPTURE, ( mBracketRangePositive + 1 ), (int) &mStartCapture);
2524
2525	#else
2526
2527	ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_BRACKET_CAPTURE, ( mBracketRangePositive + 1 ));
2528
2529	#endif
2530
2531	}
2532	}
2533
2534	return ret;
2535	}
2536
2537	status_t CameraHal::stopImageBracketing()
2538	{
2539	status_t ret = NO_ERROR;
2540
2541	LOG_FUNCTION_NAME;
2542
2543	if( !previewEnabled() )
2544	{
2545	return NO_INIT;
2546	}
2547
2548	mBracketingRunning = false;
2549
2550	ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_BRACKET_CAPTURE);
2551
2552	LOG_FUNCTION_NAME_EXIT;
2553
2554	return ret;
2555	}
2556
2557	/**
2558	@brief Take a picture.
2559
2560	@param none
2561	@return NO_ERROR If able to switch to image capture
2562	@todo Define error codes if unable to switch to image capture
2563
2564	*/
2565	status_t CameraHal::takePicture( )
2566	{
2567	status_t ret = NO_ERROR;
2568	CameraFrame frame;
2569	CameraAdapter::BuffersDescriptor desc;
2570	int burst;
2571	const char *valstr = NULL;
2572	unsigned int bufferCount = 1;
2573
2574	Mutex::Autolock lock(mLock);
2575
2576	#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
2577
2578	gettimeofday(&mStartCapture, NULL);
2579
2580	#endif
2581
2582	LOG_FUNCTION_NAME;
2583
2584	if(!previewEnabled() && !mDisplayPaused)
2585	{
2586	LOG_FUNCTION_NAME_EXIT;
2587	CAMHAL_LOGEA("Preview not started...");
2588	return NO_INIT;
2589	}
2590
2591	// return error if we are already capturing
2592	if((mCameraAdapter->getState() == CameraAdapter::CAPTURE_STATE &&
2593	mCameraAdapter->getNextState() != CameraAdapter::PREVIEW_STATE) ||
2594	(mCameraAdapter->getState() == CameraAdapter::VIDEO_CAPTURE_STATE &&
2595	mCameraAdapter->getNextState() != CameraAdapter::VIDEO_STATE) ) {
2596	CAMHAL_LOGEA("Already capturing an image...");
2597	return NO_INIT;
2598	}
2599
2600	// we only support video snapshot if we are in video mode (recording hint is set)
2601	valstr = mParameters.get(ExCameraParameters::KEY_CAP_MODE);
2602	if((mCameraAdapter->getState() == CameraAdapter::VIDEO_STATE) &&
2603	(valstr && strcmp(valstr, ExCameraParameters::VIDEO_MODE)) ) {
2604	CAMHAL_LOGEA("Trying to capture while recording without recording hint set...");
2605	return INVALID_OPERATION;
2606	}
2607
2608	if ( !mBracketingRunning )
2609	{
2610	if ( NO_ERROR == ret )
2611	{
2612	burst = mParameters.getInt(ExCameraParameters::KEY_BURST);
2613	}
2614
2615	//Allocate all buffers only in burst capture case
2616	if ( burst > 1 )
2617	{
2618	bufferCount = CameraHal::NO_BUFFERS_IMAGE_CAPTURE;
2619	if ( NULL != mAppCallbackNotifier.get() )
2620	{
2621	mAppCallbackNotifier->setBurst(true);
2622	}
2623	}
2624	else
2625	{
2626	if ( NULL != mAppCallbackNotifier.get() )
2627	{
2628	mAppCallbackNotifier->setBurst(false);
2629	}
2630	}
2631
2632	// pause preview during normal image capture
2633	// do not pause preview if recording (video state)
2634	if (NO_ERROR == ret &&
2635	NULL != mDisplayAdapter.get() &&
2636	burst < 1) {
2637	if (mCameraAdapter->getState() != CameraAdapter::VIDEO_STATE) {
2638	mDisplayPaused = true;
2639	mPreviewEnabled = false;
2640	ret = mDisplayAdapter->pauseDisplay(mDisplayPaused);
2641	// since preview is paused we should stop sending preview frames too
2642	if(mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME) {
2643	mAppCallbackNotifier->disableMsgType (mMsgEnabled & CAMERA_MSG_POSTVIEW_FRAME);
2644	CAMHAL_LOGDA("disable MSG_PREVIEW_FRAME");
2645	}
2646	}
2647
2648	#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
2649	mDisplayAdapter->setSnapshotTimeRef(&mStartCapture);
2650	#endif
2651	}
2652
2653	// if we taking video snapshot...
2654	if ((NO_ERROR == ret) && (mCameraAdapter->getState() == CameraAdapter::VIDEO_STATE)) {
2655	// enable post view frames if not already enabled so we can internally
2656	// save snapshot frames for generating thumbnail
2657	if((mMsgEnabled & CAMERA_MSG_POSTVIEW_FRAME) == 0) {
2658	mAppCallbackNotifier->enableMsgType(CAMERA_MSG_POSTVIEW_FRAME);
2659	}
2660	}
2661
2662	if ( (NO_ERROR == ret) && (NULL != mCameraAdapter) )
2663	{
2664	if ( NO_ERROR == ret )
2665	ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE,
2666	( int ) &frame,
2667	bufferCount);
2668
2669	if ( NO_ERROR != ret )
2670	{
2671	CAMHAL_LOGEB("CAMERA_QUERY_BUFFER_SIZE_IMAGE_CAPTURE returned error 0x%x, count:%d", ret,bufferCount);
2672	}
2673	}
2674
2675	if ( NO_ERROR == ret )
2676	{
2677	mParameters.getPictureSize(( int * ) &frame.mWidth,
2678	( int * ) &frame.mHeight);
2679
2680	ret = allocImageBufs(frame.mWidth,
2681	frame.mHeight,
2682	frame.mLength,
2683	mParameters.getPictureFormat(),
2684	bufferCount);
2685	if ( NO_ERROR != ret )
2686	{
2687	CAMHAL_LOGEB("allocImageBufs returned error 0x%x", ret);
2688	}
2689	}
2690
2691	if ( (NO_ERROR == ret) && ( NULL != mCameraAdapter ) )
2692	{
2693	desc.mBuffers = mImageBufs;
2694	desc.mOffsets = mImageOffsets;
2695	desc.mFd = mImageFd;
2696	desc.mLength = mImageLength;
2697	desc.mCount = ( size_t ) bufferCount;
2698	desc.mMaxQueueable = ( size_t ) bufferCount;
2699
2700	ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_USE_BUFFERS_IMAGE_CAPTURE, ( int ) &desc);
2701	}
2702	}
2703
2704	if ( ( NO_ERROR == ret ) && ( NULL != mCameraAdapter ) )
2705	{
2706	#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
2707	//pass capture timestamp along with the camera adapter command
2708	ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_IMAGE_CAPTURE, (int) &mStartCapture);
2709	#else
2710	ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_IMAGE_CAPTURE);
2711	#endif
2712	}
2713
2714	return ret;
2715	}
2716
2717	/**
2718	@brief Cancel a picture that was started with takePicture.
2719
2720	Calling this method when no picture is being taken is a no-op.
2721
2722	@param none
2723	@return NO_ERROR If cancel succeeded. Cancel can succeed if image callback is not sent
2724	@todo Define error codes
2725
2726	*/
2727	status_t CameraHal::cancelPicture( )
2728	{
2729	LOG_FUNCTION_NAME;
2730
2731	Mutex::Autolock lock(mLock);
2732
2733	mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_IMAGE_CAPTURE);
2734
2735	return NO_ERROR;
2736	}
2737
2738	/**
2739	@brief Return the camera parameters.
2740
2741	@param none
2742	@return Currently configured camera parameters
2743
2744	*/
2745	char* CameraHal::getParameters()
2746	{
2747	String8 params_str8;
2748	char* params_string;
2749	const char * valstr = NULL;
2750
2751	LOG_FUNCTION_NAME;
2752
2753	CAMHAL_LOGDB("KEY_PICTURE_SIZE=%s", mParameters.get(CameraParameters::KEY_PICTURE_SIZE));
2754	if( NULL != mCameraAdapter )
2755	{
2756	mCameraAdapter->getParameters(mParameters);
2757	}
2758	CAMHAL_LOGDB("KEY_PICTURE_SIZE=%s", mParameters.get(CameraParameters::KEY_PICTURE_SIZE));
2759
2760	CameraParameters mParams = mParameters;
2761
2762	// Handle RECORDING_HINT to Set/Reset Video Mode Parameters
2763	valstr = mParameters.get(CameraParameters::KEY_RECORDING_HINT);
2764	if(valstr != NULL)
2765	{
2766	if(strcmp(valstr, CameraParameters::TRUE) == 0)
2767	{
2768	//HACK FOR MMS MODE
2769	resetPreviewRes(&mParams, mVideoWidth, mVideoHeight);
2770	}
2771	}
2772
2773	// do not send internal parameters to upper layers
2774	mParams.remove(ExCameraParameters::KEY_RECORDING_HINT);
2775	mParams.remove(ExCameraParameters::KEY_AUTO_FOCUS_LOCK);
2776	mParameters.remove(CameraProperties::RELOAD_WHEN_OPEN);
2777	#ifdef AMLOGIC_VIRTUAL_CAMERA_SUPPORT
2778	mParams.remove(CameraProperties::DEVICE_NAME);
2779	#endif
2780
2781	params_str8 = mParams.flatten();
2782
2783	// camera service frees this string...
2784	params_string = (char*) malloc(sizeof(char) * (params_str8.length()+1));
2785	strcpy(params_string, params_str8.string());
2786
2787	LOG_FUNCTION_NAME_EXIT;
2788
2789	///Return the current set of parameters
2790
2791	return params_string;
2792	}
2793
2794	void CameraHal::putParameters(char *parms)
2795	{
2796	free(parms);
2797	}
2798
2799	/**
2800	@brief Send command to camera driver.
2801
2802	@param none
2803	@return NO_ERROR If the command succeeds
2804	@todo Define the error codes that this function can return
2805
2806	*/
2807	status_t CameraHal::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2)
2808	{
2809	status_t ret = NO_ERROR;
2810
2811	LOG_FUNCTION_NAME;
2812
2813	if (11 /*TODO CAMERA_APK_NAME*/==cmd)
2814	{
2815	ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_APK, arg1,arg2);
2816	}
2817	if ( ( NO_ERROR == ret ) && ( NULL == mCameraAdapter ) )
2818	{
2819	CAMHAL_LOGEA("No CameraAdapter instance");
2820	ret = -EINVAL;
2821	}
2822
2823	if ( ( NO_ERROR == ret ) && ( !previewEnabled() ))
2824	{
2825	if( cmd == CAMERA_CMD_SET_DISPLAY_ORIENTATION) {
2826	if(arg2 == 1) {//disable mirror
2827	ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_DISABLE_MIRROR, 1);
2828	}
2829	}
2830	if( CAMERA_CMD_ENABLE_FOCUS_MOVE_MSG != cmd){
2831	CAMHAL_LOGEA("Preview is not running");
2832	ret = -EINVAL;
2833	}
2834	}
2835
2836	if ( NO_ERROR == ret )
2837	{
2838	switch(cmd)
2839	{
2840	case CAMERA_CMD_SET_DISPLAY_ORIENTATION:
2841
2842	if(arg2 == 1) {//disable mirror
2843	ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_DISABLE_MIRROR, 1);
2844	}
2845
2846	break;
2847	case CAMERA_CMD_START_SMOOTH_ZOOM:
2848
2849	ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_SMOOTH_ZOOM, arg1);
2850
2851	break;
2852	case CAMERA_CMD_STOP_SMOOTH_ZOOM:
2853
2854	ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_SMOOTH_ZOOM);
2855
2856	case CAMERA_CMD_START_FACE_DETECTION:
2857
2858	ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_START_FD);
2859
2860	break;
2861
2862	case CAMERA_CMD_STOP_FACE_DETECTION:
2863
2864	ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_FD);
2865
2866	break;
2867
2868	case CAMERA_CMD_ENABLE_FOCUS_MOVE_MSG:
2869
2870	mMsgEnabled |= CAMERA_MSG_FOCUS_MOVE;
2871
2872	ret = mCameraAdapter->sendCommand(CameraAdapter::CAMERA_FOCUS_MOVE_MSG);
2873
2874	break;
2875
2876	default:
2877	break;
2878	};
2879	}
2880
2881	LOG_FUNCTION_NAME_EXIT;
2882
2883	return ret;
2884	}
2885
2886	/**
2887	@brief Release the hardware resources owned by this object.
2888
2889	Note that this is *not* done in the destructor.
2890
2891	@param none
2892	@return none
2893
2894	*/
2895	void CameraHal::release()
2896	{
2897	LOG_FUNCTION_NAME;
2898	///@todo Investigate on how release is used by CameraService. Vaguely remember that this is called
2899	///just before CameraHal object destruction
2900	deinitialize();
2901
2902	SYS_enable_nextvideo();
2903	SYS_reset_zoom();
2904
2905	LOG_FUNCTION_NAME_EXIT;
2906	}
2907
2908
2909	/**
2910	@brief Dump state of the camera hardware
2911
2912	@param[in] fd File descriptor
2913	@param[in] args Arguments
2914	@return NO_ERROR Dump succeeded
2915	@todo Error codes for dump fail
2916
2917	*/
2918	status_t CameraHal::dump(int fd) const
2919	{
2920	LOG_FUNCTION_NAME;
2921	///Implement this method when the h/w dump function is supported on Ducati side
2922	return NO_ERROR;
2923	}
2924
2925	/*-------------Camera Hal Interface Method definitions ENDS here--------------------*/
2926
2927
2928
2929
2930	/*-------------Camera Hal Internal Method definitions STARTS here--------------------*/
2931
2932	/**
2933	@brief Constructor of CameraHal
2934
2935	Member variables are initialized here. No allocations should be done here as we
2936	don't use c++ exceptions in the code.
2937
2938	*/
2939	CameraHal::CameraHal(int cameraId)
2940	{
2941	LOG_FUNCTION_NAME;
2942
2943	///Initialize all the member variables to their defaults
2944	mPreviewEnabled = false;
2945	mPreviewBufs = NULL;
2946	mImageBufs = NULL;
2947	mBufProvider = NULL;
2948	mPreviewStartInProgress = false;
2949	mVideoBufs = NULL;
2950	mVideoBufProvider = NULL;
2951	mRecordingEnabled = false;
2952	mDisplayPaused = false;
2953	mSetPreviewWindowCalled = false;
2954	mMsgEnabled = 0;
2955	mAppCallbackNotifier = NULL;
2956	mMemoryManager = NULL;
2957	mCameraAdapter = NULL;
2958	mBracketingEnabled = false;
2959	mBracketingRunning = false;
2960	mEventProvider = NULL;
2961	mBracketRangePositive = 1;
2962	mBracketRangeNegative = 1;
2963	mMaxZoomSupported = 0;
2964	mShutterEnabled = true;
2965	mMeasurementEnabled = false;
2966	mPreviewDataBufs = NULL;
2967	mCameraProperties = NULL;
2968	mCurrentTime = 0;
2969	mFalsePreview = 0;
2970	mImageOffsets = NULL;
2971	mImageLength = 0;
2972	mImageFd = -1;
2973	mVideoOffsets = NULL;
2974	mVideoFd = -1;
2975	mVideoLength = 0;
2976	mPreviewDataOffsets = NULL;
2977	mPreviewDataFd = -1;
2978	mPreviewDataLength = 0;
2979	mPreviewFd = -1;
2980	mPreviewWidth = 0;
2981	mPreviewHeight = 0;
2982	mPreviewLength = 0;
2983	mPreviewOffsets = NULL;
2984	mPreviewRunning = 0;
2985	mPreviewStateOld = 0;
2986	mRecordingEnabled = 0;
2987	mRecordEnabled = 0;
2988	#ifdef ENABLE_SENSOR_LISTENER
2989	mSensorListener = NULL;
2990	#endif
2991	mVideoWidth = 0;
2992	mVideoHeight = 0;
2993
2994	#if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
2995
2996	//Initialize the CameraHAL constructor timestamp, which is used in the
2997	// PPM() method as time reference if the user does not supply one.
2998	gettimeofday(&ppm_start, NULL);
2999
3000	#endif
3001
3002	mCameraIndex = cameraId;
3003
3004	SYS_disable_avsync();
3005	SYS_disable_video_pause();
3006	#ifdef AMLOGIC_CAMERA_OVERLAY_SUPPORT
3007	SYS_enable_nextvideo();
3008	#else
3009	SYS_close_video();
3010	#endif
3011	refCount = 0;
3012
3013	LOG_FUNCTION_NAME_EXIT;
3014	}
3015
3016	/**
3017	@brief Destructor of CameraHal
3018
3019	This function simply calls deinitialize() to free up memory allocate during construct
3020	phase
3021	*/
3022	CameraHal::~CameraHal()
3023	{
3024	LOG_FUNCTION_NAME;
3025
3026	///Call de-initialize here once more - it is the last chance for us to relinquish all the h/w and s/w resources
3027	deinitialize();
3028
3029	if ( NULL != mEventProvider )
3030	{
3031	mEventProvider->disableEventNotification(CameraHalEvent::ALL_EVENTS);
3032	delete mEventProvider;
3033	mEventProvider = NULL;
3034	}
3035
3036	/// Free the callback notifier
3037	mAppCallbackNotifier.clear();
3038
3039	/// Free the display adapter
3040	mDisplayAdapter.clear();
3041
3042	if ( NULL != mCameraAdapter ) {
3043	int strongCount = mCameraAdapter->getStrongCount();
3044
3045	mCameraAdapter->decStrong(mCameraAdapter);
3046
3047	mCameraAdapter = NULL;
3048	}
3049
3050	freeImageBufs();
3051
3052	/// Free the memory manager
3053	mMemoryManager.clear();
3054
3055	SYS_enable_nextvideo();
3056	SYS_reset_zoom();
3057
3058	LOG_FUNCTION_NAME_EXIT;
3059	}
3060
3061	/**
3062	@brief Initialize the Camera HAL
3063
3064	Creates CameraAdapter, AppCallbackNotifier, DisplayAdapter and MemoryManager
3065
3066	@param None
3067	@return NO_ERROR - On success
3068	NO_MEMORY - On failure to allocate memory for any of the objects
3069	@remarks Camera Hal internal function
3070
3071	*/
3072
3073	status_t CameraHal::initialize(CameraProperties::Properties* properties)
3074	{
3075	LOG_FUNCTION_NAME;
3076
3077	int sensor_index = 0;
3078
3079	///Initialize the event mask used for registering an event provider for AppCallbackNotifier
3080	///Currently, registering all events as to be coming from CameraAdapter
3081	int32_t eventMask = CameraHalEvent::ALL_EVENTS;
3082
3083	// Get my camera properties
3084	mCameraProperties = properties;
3085
3086	if(!mCameraProperties)
3087	{
3088	goto fail_loop;
3089	}
3090
3091	// Dump the properties of this Camera
3092	// will only print if DEBUG macro is defined
3093	mCameraProperties->dump();
3094
3095	if (strcmp(CameraProperties::DEFAULT_VALUE, mCameraProperties->get(CameraProperties::CAMERA_SENSOR_INDEX)) != 0 )
3096	{
3097	sensor_index = atoi(mCameraProperties->get(CameraProperties::CAMERA_SENSOR_INDEX));
3098	}
3099
3100	CAMHAL_LOGDB("Sensor index %d", sensor_index);
3101
3102	mCameraAdapter = CameraAdapter_Factory(sensor_index);
3103	if ( ( NULL == mCameraAdapter ) || (mCameraAdapter->initialize(properties)!=NO_ERROR))
3104	{
3105	CAMHAL_LOGEA("Unable to create or initialize CameraAdapter");
3106	mCameraAdapter = NULL;
3107	goto fail_loop;
3108	}
3109
3110	mCameraAdapter->incStrong(mCameraAdapter);
3111	mCameraAdapter->registerImageReleaseCallback(releaseImageBuffers, (void *) this);
3112	mCameraAdapter->registerEndCaptureCallback(endImageCapture, (void *)this);
3113
3114	if(!mAppCallbackNotifier.get())
3115	{
3116	/// Create the callback notifier
3117	mAppCallbackNotifier = new AppCallbackNotifier();
3118	if( ( NULL == mAppCallbackNotifier.get() ) || ( mAppCallbackNotifier->initialize() != NO_ERROR))
3119	{
3120	CAMHAL_LOGEA("Unable to create or initialize AppCallbackNotifier");
3121	goto fail_loop;
3122	}
3123	}
3124
3125	if(!mMemoryManager.get())
3126	{
3127	/// Create Memory Manager
3128	mMemoryManager = new MemoryManager();
3129	if( ( NULL == mMemoryManager.get() ) || ( mMemoryManager->initialize() != NO_ERROR))
3130	{
3131	CAMHAL_LOGEA("Unable to create or initialize MemoryManager");
3132	goto fail_loop;
3133	}
3134	}
3135
3136	///Setup the class dependencies...
3137
3138	///AppCallbackNotifier has to know where to get the Camera frames and the events like auto focus lock etc from.
3139	///CameraAdapter is the one which provides those events
3140	///Set it as the frame and event providers for AppCallbackNotifier
3141	///@remarks setEventProvider API takes in a bit mask of events for registering a provider for the different events
3142	/// That way, if events can come from DisplayAdapter in future, we will be able to add it as provider
3143	/// for any event
3144	mAppCallbackNotifier->setEventProvider(eventMask, mCameraAdapter);
3145	mAppCallbackNotifier->setFrameProvider(mCameraAdapter);
3146
3147	///Any dynamic errors that happen during the camera use case has to be propagated back to the application
3148	///via CAMERA_MSG_ERROR. AppCallbackNotifier is the class that notifies such errors to the application
3149	///Set it as the error handler for CameraAdapter
3150	mCameraAdapter->setErrorHandler(mAppCallbackNotifier.get());
3151
3152	///Start the callback notifier
3153	if(mAppCallbackNotifier->start() != NO_ERROR)
3154	{
3155	CAMHAL_LOGEA("Couldn't start AppCallbackNotifier");
3156	goto fail_loop;
3157	}
3158
3159	CAMHAL_LOGDA("Started AppCallbackNotifier..");
3160	mAppCallbackNotifier->setMeasurements(mMeasurementEnabled);
3161
3162	///Initialize default parameters
3163	initDefaultParameters();
3164
3165	if ( setParameters(mParameters) != NO_ERROR )
3166	{
3167	CAMHAL_LOGEA("Failed to set default parameters?!");
3168	}
3169
3170	#ifdef ENABLE_SENSOR_LISTENER
3171	// register for sensor events
3172	mSensorListener = new SensorListener();
3173	if (mSensorListener.get()) {
3174	if (mSensorListener->initialize() == NO_ERROR) {
3175	mSensorListener->setCallbacks(orientation_cb, this);
3176	mSensorListener->enableSensor(SensorListener::SENSOR_ORIENTATION);
3177	} else {
3178	CAMHAL_LOGEA("Error initializing SensorListener. not fatal, continuing");
3179	mSensorListener.clear();
3180	mSensorListener = NULL;
3181	}
3182	}
3183	#endif
3184
3185	LOG_FUNCTION_NAME_EXIT;
3186	return NO_ERROR;
3187
3188	fail_loop:
3189
3190	///Free up the resources because we failed somewhere up
3191	deinitialize();
3192	LOG_FUNCTION_NAME_EXIT;
3193
3194	return NO_MEMORY;
3195
3196	}
3197
3198	#ifndef AMLOGIC_USB_CAMERA_SUPPORT
3199	//By vm or mipi driver, the resolution only need be smaller the max preview size. (1920*1080)
3200	bool CameraHal::isResolutionValid(unsigned int width, unsigned int height, const char *supportedResolutions)
3201	{
3202	bool ret = false;
3203	status_t status = NO_ERROR;
3204	char *pos = NULL;
3205	unsigned int supported_w = 0, supported_h = 0;
3206	LOG_FUNCTION_NAME;
3207
3208	if ( NULL == supportedResolutions )
3209	{
3210	CAMHAL_LOGEA("Invalid supported resolutions string");
3211	ret = false;
3212	goto exit;
3213	}
3214	pos = (char *)supportedResolutions;
3215	while(pos != NULL){
3216	if (sscanf(pos, "%dx%d", &supported_w, &supported_h) != 2){
3217	CAMHAL_LOGEB("Read supported resolutions string error!(%s)",pos);
3218	ret = false;
3219	break;
3220	}
3221	//CAMHAL_LOGVB("Read supported resolutions %dx%d",supported_w,supported_h);
3222	if((width<=supported_w)&&(height<=supported_h)){
3223	ret = true;
3224	break;
3225	}
3226	pos = strchr(pos, ',');
3227	if(pos)
3228	pos++;
3229	}
3230
3231	exit:
3232
3233	LOG_FUNCTION_NAME_EXIT;
3234	return ret;
3235	}
3236	#else
3237	bool CameraHal::isResolutionValid(unsigned int width, unsigned int height, const char *supportedResolutions)
3238	{
3239	bool ret = true;
3240	status_t status = NO_ERROR;
3241	char tmpBuffer[PARAM_BUFFER + 1];
3242	char *pos = NULL;
3243
3244	LOG_FUNCTION_NAME;
3245
3246	if ( NULL == supportedResolutions )
3247	{
3248	CAMHAL_LOGEA("Invalid supported resolutions string");
3249	ret = false;
3250	goto exit;
3251	}
3252
3253	status = snprintf(tmpBuffer, PARAM_BUFFER, "%dx%d", width, height);
3254	if ( 0 > status )
3255	{
3256	CAMHAL_LOGEA("Error encountered while generating validation string");
3257	ret = false;
3258	goto exit;
3259	}
3260
3261	pos = strstr(supportedResolutions, tmpBuffer);
3262	if ( NULL == pos )
3263	{
3264	ret = false;
3265	}
3266	else
3267	{
3268	ret = true;
3269	}
3270
3271	exit:
3272
3273	LOG_FUNCTION_NAME_EXIT;
3274
3275	return ret;
3276	}
3277	#endif
3278
3279	bool CameraHal::isParameterValid(const char *param, const char *supportedParams)
3280	{
3281	bool ret = true;
3282	char *pos = NULL;
3283
3284	LOG_FUNCTION_NAME;
3285
3286	if ( NULL == supportedParams )
3287	{
3288	CAMHAL_LOGEA("Invalid supported parameters string");
3289	ret = false;
3290	goto exit;
3291	}
3292
3293	if ( NULL == param )
3294	{
3295	CAMHAL_LOGEA("Invalid parameter string");
3296	ret = false;
3297	goto exit;
3298	}
3299
3300	pos = strstr(supportedParams, param);
3301	if ( NULL == pos )
3302	{
3303	ret = false;
3304	}
3305	else
3306	{
3307	ret = true;
3308	}
3309
3310	exit:
3311
3312	LOG_FUNCTION_NAME_EXIT;
3313
3314	return ret;
3315	}
3316
3317	bool CameraHal::isParameterValid(int param, const char *supportedParams)
3318	{
3319	bool ret = true;
3320	char *pos = NULL;
3321	status_t status;
3322	char tmpBuffer[PARAM_BUFFER + 1];
3323
3324	LOG_FUNCTION_NAME;
3325
3326	if ( NULL == supportedParams )
3327	{
3328	CAMHAL_LOGEA("Invalid supported parameters string");
3329	ret = false;
3330	goto exit;
3331	}
3332
3333	status = snprintf(tmpBuffer, PARAM_BUFFER, "%d", param);
3334	if ( 0 > status )
3335	{
3336	CAMHAL_LOGEA("Error encountered while generating validation string");
3337	ret = false;
3338	goto exit;
3339	}
3340
3341	pos = strstr(supportedParams, tmpBuffer);
3342	if ( NULL == pos )
3343	{
3344	ret = false;
3345	}
3346	else
3347	{
3348	ret = true;
3349	}
3350
3351	exit:
3352
3353	LOG_FUNCTION_NAME_EXIT;
3354
3355	return ret;
3356	}
3357
3358	bool CameraHal::isParameterInRange(int param, const char *supportedParams)
3359	{
3360	bool ret = true;
3361	char *pos = NULL;
3362	status_t status;
3363	int min_range = 0, max_range = 0;
3364
3365	LOG_FUNCTION_NAME;
3366
3367	if ( NULL == supportedParams )
3368	{
3369	CAMHAL_LOGEA("Invalid supported parameters string");
3370	ret = false;
3371	goto exit;
3372	}
3373	if (sscanf(supportedParams, "%d,%d", &min_range, &max_range) != 2){
3374	CAMHAL_LOGEA("Error encountered while get Parameter Range");
3375	ret = false;
3376	goto exit;
3377	}
3378	if(min_range==max_range){
3379	CAMHAL_LOGEA("Parameter Range Invalid");
3380	ret = false;
3381	goto exit;
3382	}
3383
3384	if(min_range>max_range){
3385	int temp = max_range;
3386	max_range = min_range;
3387	min_range = temp;
3388	}
3389
3390	if((min_range<=param)&&(param<=max_range))
3391	ret = true;
3392	else
3393	ret = false;
3394	exit:
3395
3396	LOG_FUNCTION_NAME_EXIT;
3397
3398	return ret;
3399	}
3400
3401	status_t CameraHal::doesSetParameterNeedUpdate(const char* new_param, const char* old_param, bool& update)
3402	{
3403	if (!new_param || !old_param) {
3404	return -EINVAL;
3405	}
3406
3407	// if params mismatch we should update parameters for camera adapter
3408	if ((strcmp(new_param, old_param) != 0)) {
3409	update = true;
3410	}
3411
3412	return NO_ERROR;
3413	}
3414
3415	status_t CameraHal::parseResolution(const char *resStr, int &width, int &height)
3416	{
3417	status_t ret = NO_ERROR;
3418	char *ctx, *pWidth, *pHeight;
3419	const char *sep = "x";
3420	char *tmp = NULL;
3421
3422	LOG_FUNCTION_NAME;
3423
3424	if ( NULL == resStr )
3425	{
3426	return -EINVAL;
3427	}
3428
3429	//This fixes "Invalid input resolution"
3430	char *resStr_copy = (char *)malloc(strlen(resStr) + 1);
3431	if ( NULL!=resStr_copy ) {
3432	if ( NO_ERROR == ret )
3433	{
3434	strcpy(resStr_copy, resStr);
3435	pWidth = strtok_r( (char *) resStr_copy, sep, &ctx);
3436
3437	if ( NULL != pWidth )
3438	{
3439	width = atoi(pWidth);
3440	}
3441	else
3442	{
3443	CAMHAL_LOGEB("Invalid input resolution %s", resStr);
3444	ret = -EINVAL;
3445	}
3446	}
3447
3448	if ( NO_ERROR == ret )
3449	{
3450	pHeight = strtok_r(NULL, sep, &ctx);
3451
3452	if ( NULL != pHeight )
3453	{
3454	height = atoi(pHeight);
3455	}
3456	else
3457	{
3458	CAMHAL_LOGEB("Invalid input resolution %s", resStr);
3459	ret = -EINVAL;
3460	}
3461	}
3462
3463	free(resStr_copy);
3464	resStr_copy = NULL;
3465	}
3466	LOG_FUNCTION_NAME_EXIT;
3467
3468	return ret;
3469	}
3470
3471	void CameraHal::insertSupportedParams()
3472	{
3473	char tmpBuffer[PARAM_BUFFER + 1];
3474
3475	LOG_FUNCTION_NAME;
3476
3477	CameraParameters &p = mParameters;
3478
3479	///Set the name of the camera
3480	p.set(ExCameraParameters::KEY_CAMERA_NAME, mCameraProperties->get(CameraProperties::CAMERA_NAME));
3481
3482	mMaxZoomSupported = atoi(mCameraProperties->get(CameraProperties::SUPPORTED_ZOOM_STAGES));
3483
3484	p.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_SIZES));
3485	p.set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS, mCameraProperties->get(CameraProperties::SUPPORTED_PICTURE_FORMATS));
3486	p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_SIZES));
3487	p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FORMATS));
3488	p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_FRAME_RATES));
3489	p.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_THUMBNAIL_SIZES));
3490	p.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE, mCameraProperties->get(CameraProperties::SUPPORTED_WHITE_BALANCE));
3491	p.set(CameraParameters::KEY_SUPPORTED_EFFECTS, mCameraProperties->get(CameraProperties::SUPPORTED_EFFECTS));
3492	p.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES, mCameraProperties->get(CameraProperties::SUPPORTED_SCENE_MODES));
3493
3494	const char *flashmode = mCameraProperties->get(CameraProperties::SUPPORTED_FLASH_MODES);
3495	if(flashmode&&(flashmode[0]!=0)){
3496	p.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, flashmode);
3497	}
3498
3499	p.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES, mCameraProperties->get(CameraProperties::SUPPORTED_FOCUS_MODES));
3500	p.set(CameraParameters::KEY_SUPPORTED_ANTIBANDING, mCameraProperties->get(CameraProperties::SUPPORTED_ANTIBANDING));
3501	p.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION, mCameraProperties->get(CameraProperties::SUPPORTED_EV_MAX));
3502	p.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION, mCameraProperties->get(CameraProperties::SUPPORTED_EV_MIN));
3503	p.set(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP, mCameraProperties->get(CameraProperties::SUPPORTED_EV_STEP));
3504	p.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES, mCameraProperties->get(CameraProperties::SUPPORTED_SCENE_MODES));
3505	p.set(ExCameraParameters::KEY_SUPPORTED_EXPOSURE, mCameraProperties->get(CameraProperties::SUPPORTED_EXPOSURE_MODES));
3506	p.set(ExCameraParameters::KEY_SUPPORTED_ISO_VALUES, mCameraProperties->get(CameraProperties::SUPPORTED_ISO_VALUES));
3507	p.set(CameraParameters::KEY_ZOOM_RATIOS, mCameraProperties->get(CameraProperties::SUPPORTED_ZOOM_RATIOS));
3508	p.set(CameraParameters::KEY_MAX_ZOOM, mCameraProperties->get(CameraProperties::SUPPORTED_ZOOM_STAGES));
3509	p.set(CameraParameters::KEY_ZOOM_SUPPORTED, mCameraProperties->get(CameraProperties::ZOOM_SUPPORTED));
3510	p.set(CameraParameters::KEY_SMOOTH_ZOOM_SUPPORTED, mCameraProperties->get(CameraProperties::SMOOTH_ZOOM_SUPPORTED));
3511	p.set(ExCameraParameters::KEY_SUPPORTED_IPP, mCameraProperties->get(CameraProperties::SUPPORTED_IPP_MODES));
3512	p.set(ExCameraParameters::KEY_S3D_SUPPORTED,mCameraProperties->get(CameraProperties::S3D_SUPPORTED));
3513	p.set(ExCameraParameters::KEY_S3D2D_PREVIEW_MODE,mCameraProperties->get(CameraProperties::S3D2D_PREVIEW_MODES));
3514	p.set(ExCameraParameters::KEY_AUTOCONVERGENCE_MODE, mCameraProperties->get(CameraProperties::AUTOCONVERGENCE_MODE));
3515	p.set(ExCameraParameters::KEY_MANUALCONVERGENCE_VALUES, mCameraProperties->get(CameraProperties::MANUALCONVERGENCE_VALUES));
3516	p.set(CameraParameters::KEY_VIDEO_STABILIZATION_SUPPORTED, mCameraProperties->get(CameraProperties::VSTAB_SUPPORTED));
3517	p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, mCameraProperties->get(CameraProperties::FRAMERATE_RANGE_SUPPORTED));
3518	p.set(ExCameraParameters::KEY_SENSOR_ORIENTATION, mCameraProperties->get(CameraProperties::SENSOR_ORIENTATION));
3519	p.set(ExCameraParameters::KEY_SENSOR_ORIENTATION_VALUES, mCameraProperties->get(CameraProperties::SENSOR_ORIENTATION_VALUES));
3520	p.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK_SUPPORTED, mCameraProperties->get(CameraProperties::AUTO_EXPOSURE_LOCK_SUPPORTED));
3521	p.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED, mCameraProperties->get(CameraProperties::AUTO_WHITEBALANCE_LOCK_SUPPORTED));
3522	p.set(CameraParameters::KEY_VIDEO_SNAPSHOT_SUPPORTED, mCameraProperties->get(CameraProperties::VIDEO_SNAPSHOT_SUPPORTED));
3523
3524	//p.set(CameraParameters::KEY_SUPPORTED_VIDEO_SIZES, mCameraProperties->get(CameraProperties::SUPPORTED_PREVIEW_SIZES));
3525
3526	p.set(CameraParameters::KEY_FOCUS_DISTANCES,"0.95,1.9,Infinity");
3527
3528	LOG_FUNCTION_NAME_EXIT;
3529
3530	}
3531
3532	void CameraHal::initDefaultParameters()
3533	{
3534	//Purpose of this function is to initialize the default current and supported parameters for the currently
3535	//selected camera.
3536
3537	CameraParameters &p = mParameters;
3538	int currentRevision, adapterRevision;
3539	status_t ret = NO_ERROR;
3540	int width, height;
3541
3542	LOG_FUNCTION_NAME;
3543
3544	ret = parseResolution(mCameraProperties->get(CameraProperties::PREVIEW_SIZE), width, height);
3545
3546	if ( NO_ERROR == ret )
3547	{
3548	p.setPreviewSize(width, height);
3549	}
3550	else
3551	{
3552	p.setPreviewSize(MIN_WIDTH, MIN_HEIGHT);
3553	}
3554
3555	ret = parseResolution(mCameraProperties->get(CameraProperties::PICTURE_SIZE), width, height);
3556
3557	if ( NO_ERROR == ret )
3558	{
3559	p.setPictureSize(width, height);
3560	}
3561	else
3562	{
3563	p.setPictureSize(PICTURE_WIDTH, PICTURE_HEIGHT);
3564	}
3565
3566	ret = parseResolution(mCameraProperties->get(CameraProperties::JPEG_THUMBNAIL_SIZE), width, height);
3567
3568	if ( NO_ERROR == ret )
3569	{
3570	p.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, width);
3571	p.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, height);
3572	}
3573	else
3574	{
3575	p.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, MIN_WIDTH);
3576	p.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, MIN_HEIGHT);
3577	}
3578
3579	insertSupportedParams();
3580
3581	//Insert default values
3582	p.setPreviewFrameRate(atoi(mCameraProperties->get(CameraProperties::PREVIEW_FRAME_RATE)));
3583	p.setPreviewFormat(mCameraProperties->get(CameraProperties::PREVIEW_FORMAT));
3584	p.setPictureFormat(mCameraProperties->get(CameraProperties::PICTURE_FORMAT));
3585	p.set(CameraParameters::KEY_JPEG_QUALITY, mCameraProperties->get(CameraProperties::JPEG_QUALITY));
3586	p.set(CameraParameters::KEY_WHITE_BALANCE, mCameraProperties->get(CameraProperties::WHITEBALANCE));
3587	p.set(CameraParameters::KEY_EFFECT, mCameraProperties->get(CameraProperties::EFFECT));
3588	p.set(CameraParameters::KEY_ANTIBANDING, mCameraProperties->get(CameraProperties::ANTIBANDING));
3589	p.set(CameraParameters::KEY_FOCUS_MODE, mCameraProperties->get(CameraProperties::FOCUS_MODE));
3590	p.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, mCameraProperties->get(CameraProperties::EV_COMPENSATION));
3591	p.set(CameraParameters::KEY_SCENE_MODE, mCameraProperties->get(CameraProperties::SCENE_MODE));
3592
3593	const char *flashmode = mCameraProperties->get(CameraProperties::FLASH_MODE);
3594	if(flashmode&&(flashmode[0]!=0)){
3595	p.set(CameraParameters::KEY_FLASH_MODE, flashmode);
3596	}
3597
3598	p.set(CameraParameters::KEY_ZOOM, mCameraProperties->get(CameraProperties::ZOOM));
3599	p.set(ExCameraParameters::KEY_CONTRAST, mCameraProperties->get(CameraProperties::CONTRAST));
3600	p.set(ExCameraParameters::KEY_SATURATION, mCameraProperties->get(CameraProperties::SATURATION));
3601	p.set(ExCameraParameters::KEY_BRIGHTNESS, mCameraProperties->get(CameraProperties::BRIGHTNESS));
3602	p.set(ExCameraParameters::KEY_SHARPNESS, mCameraProperties->get(CameraProperties::SHARPNESS));
3603	p.set(ExCameraParameters::KEY_EXPOSURE_MODE, mCameraProperties->get(CameraProperties::EXPOSURE_MODE));
3604	p.set(ExCameraParameters::KEY_ISO, mCameraProperties->get(CameraProperties::ISO_MODE));
3605	p.set(ExCameraParameters::KEY_IPP, mCameraProperties->get(CameraProperties::IPP));
3606	p.set(ExCameraParameters::KEY_GBCE, mCameraProperties->get(CameraProperties::GBCE));
3607	p.set(ExCameraParameters::KEY_S3D2D_PREVIEW, mCameraProperties->get(CameraProperties::S3D2D_PREVIEW));
3608	p.set(ExCameraParameters::KEY_AUTOCONVERGENCE, mCameraProperties->get(CameraProperties::AUTOCONVERGENCE));
3609	p.set(ExCameraParameters::KEY_MANUALCONVERGENCE_VALUES, mCameraProperties->get(CameraProperties::MANUALCONVERGENCE_VALUES));
3610	p.set(CameraParameters::KEY_VIDEO_STABILIZATION, mCameraProperties->get(CameraProperties::VSTAB));
3611	p.set(CameraParameters::KEY_FOCAL_LENGTH, mCameraProperties->get(CameraProperties::FOCAL_LENGTH));
3612	p.set(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, mCameraProperties->get(CameraProperties::HOR_ANGLE));
3613	p.set(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, mCameraProperties->get(CameraProperties::VER_ANGLE));
3614	p.set(CameraParameters::KEY_PREVIEW_FPS_RANGE,mCameraProperties->get(CameraProperties::FRAMERATE_RANGE));
3615	p.set(ExCameraParameters::KEY_SENSOR_ORIENTATION, mCameraProperties->get(CameraProperties::SENSOR_ORIENTATION));
3616	p.set(ExCameraParameters::KEY_SENSOR_ORIENTATION_VALUES, mCameraProperties->get(CameraProperties::SENSOR_ORIENTATION_VALUES));
3617	p.set(ExCameraParameters::KEY_EXIF_MAKE, mCameraProperties->get(CameraProperties::EXIF_MAKE));
3618	p.set(ExCameraParameters::KEY_EXIF_MODEL, mCameraProperties->get(CameraProperties::EXIF_MODEL));
3619	p.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, mCameraProperties->get(CameraProperties::JPEG_THUMBNAIL_QUALITY));
3620	p.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT, (const char *) CameraParameters::PIXEL_FORMAT_YUV420SP);
3621	p.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_HW, mCameraProperties->get(CameraProperties::MAX_FD_HW_FACES));
3622	p.set(CameraParameters::KEY_MAX_NUM_DETECTED_FACES_SW, mCameraProperties->get(CameraProperties::MAX_FD_SW_FACES));
3623
3624	// Only one area a.k.a Touch AF for now.
3625	// TODO: Add support for multiple focus areas.
3626	p.set(CameraParameters::KEY_MAX_NUM_FOCUS_AREAS, mCameraProperties->get(CameraProperties::MAX_FOCUS_AREAS));
3627	p.set(CameraParameters::KEY_AUTO_EXPOSURE_LOCK, mCameraProperties->get(CameraProperties::AUTO_EXPOSURE_LOCK));
3628	p.set(CameraParameters::KEY_AUTO_WHITEBALANCE_LOCK, mCameraProperties->get(CameraProperties::AUTO_WHITEBALANCE_LOCK));
3629	p.set(CameraParameters::KEY_MAX_NUM_METERING_AREAS, mCameraProperties->get(CameraProperties::MAX_NUM_METERING_AREAS));
3630	p.set(CameraParameters::KEY_VIDEO_SIZE, mCameraProperties->get(CameraProperties::VIDEO_SIZE));
3631	//p.set(CameraParameters::KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO, mCameraProperties->get(CameraProperties::PREFERRED_PREVIEW_SIZE_FOR_VIDEO));
3632
3633	#ifdef METADATA_MODE_FOR_PREVIEW_CALLBACK
3634	p.set(ExCameraParameters::KEY_PREVEIW_CALLBACK_IN_METADATA_ENABLE,ExCameraParameters::PREVEIW_CALLBACK_IN_METADATA_DISABLE);
3635	p.set(ExCameraParameters::KEY_PREVEIW_CALLBACK_IN_METADATA_LENGTH,ExCameraParameters::PREVEIW_CALLBACK_IN_METADATA_LENGTH);
3636	#endif
3637	LOG_FUNCTION_NAME_EXIT;
3638	}
3639
3640	/**
3641	@brief Stop a previously started preview.
3642	@param none
3643	@return none
3644
3645	*/
3646	void CameraHal::forceStopPreview()
3647	{
3648	LOG_FUNCTION_NAME;
3649
3650	// stop bracketing if it is running
3651	stopImageBracketing();
3652
3653	if (mDisplayPaused){
3654	mDisplayPaused = false;
3655	mDisplayAdapter->pauseDisplay(mDisplayPaused);
3656	CAMHAL_LOGVA("native window to pause state false\n");
3657	}
3658	if(mDisplayAdapter.get() != NULL) {
3659	///Stop the buffer display first
3660	mDisplayAdapter->disableDisplay();
3661	}
3662
3663	if(mAppCallbackNotifier.get() != NULL) {
3664	//Stop the callback sending
3665	mAppCallbackNotifier->stop();
3666	mAppCallbackNotifier->flushAndReturnFrames();
3667	mAppCallbackNotifier->stopPreviewCallbacks();
3668	}
3669
3670	if ( NULL != mCameraAdapter ) {
3671	// only need to send these control commands to state machine if we are
3672	// passed the LOADED_PREVIEW_STATE
3673	if (mCameraAdapter->getState() > CameraAdapter::LOADED_PREVIEW_STATE) {
3674	// according to javadoc...FD should be stopped in stopPreview
3675	// and application needs to call startFaceDection again
3676	// to restart FD
3677	mCameraAdapter->sendCommand(CameraAdapter::CAMERA_STOP_FD);
3678	}
3679
3680	CAMHAL_LOGDA("rollback!!!!!!!!");
3681	mCameraAdapter->rollbackToInitializedState();
3682
3683	}
3684
3685	freePreviewBufs();
3686	freePreviewDataBufs();
3687
3688	mPreviewEnabled = false;
3689	mPreviewStartInProgress = false;
3690
3691	LOG_FUNCTION_NAME_EXIT;
3692	}
3693
3694	/**
3695	@brief Deallocates memory for all the resources held by Camera HAL.
3696
3697	Frees the following objects- CameraAdapter, AppCallbackNotifier, DisplayAdapter,
3698	and Memory Manager
3699
3700	@param none
3701	@return none
3702
3703	*/
3704	void CameraHal::deinitialize()
3705	{
3706	LOG_FUNCTION_NAME;
3707
3708	if ( mPreviewEnabled || mDisplayPaused ) {
3709	forceStopPreview();
3710	}
3711
3712	mSetPreviewWindowCalled = false;
3713
3714	#ifdef ENABLE_SENSOR_LISTENER
3715	if (mSensorListener.get()) {
3716	mSensorListener->disableSensor(SensorListener::SENSOR_ORIENTATION);
3717	mSensorListener.clear();
3718	mSensorListener = NULL;
3719	}
3720	#endif
3721
3722	LOG_FUNCTION_NAME_EXIT;
3723
3724	}
3725
3726	status_t CameraHal::storeMetaDataInBuffers(bool enable)
3727	{
3728	LOG_FUNCTION_NAME;
3729
3730	return mAppCallbackNotifier->useMetaDataBufferMode(enable);
3731
3732	LOG_FUNCTION_NAME_EXIT;
3733	}
3734
3735	void CameraHal::selectFPSRange(int framerate, int *min_fps, int *max_fps)
3736	{
3737	char * ptr;
3738	char supported[MAX_PROP_VALUE_LENGTH];
3739	int fpsrangeArray[2];
3740	int i = 0;
3741
3742	LOG_FUNCTION_NAME;
3743	size_t size = strlen(mCameraProperties->get(CameraProperties::FRAMERATE_RANGE_SUPPORTED))+1;
3744	strncpy(supported, mCameraProperties->get(CameraProperties::FRAMERATE_RANGE_SUPPORTED), size);
3745
3746	ptr = strtok (supported," (,)");
3747
3748	while (ptr != NULL)
3749	{
3750	fpsrangeArray[i]= atoi(ptr)/CameraHal::VFR_SCALE;
3751	if (i == 1)
3752	{
3753	if ((framerate <= fpsrangeArray[i])&&(framerate >= fpsrangeArray[i-1]))
3754	{
3755	CAMHAL_LOGDB("SETTING FPS RANGE min = %d max = %d \n", fpsrangeArray[0], fpsrangeArray[1]);
3756	*min_fps = fpsrangeArray[0]*CameraHal::VFR_SCALE;
3757	*max_fps = fpsrangeArray[1]*CameraHal::VFR_SCALE;
3758	break;
3759	}
3760	}
3761	ptr = strtok (NULL, " (,)");
3762	i++;
3763	i%=2;
3764	}
3765
3766	LOG_FUNCTION_NAME_EXIT;
3767
3768	}
3769
3770	void CameraHal::setPreferredPreviewRes(int width, int height)
3771	{
3772	LOG_FUNCTION_NAME;
3773
3774	if ( (width == 320) && (height == 240)){
3775	mParameters.setPreviewSize(640,480);
3776	}
3777	if ( (width == 176) && (height == 144)){
3778	mParameters.setPreviewSize(704,576);
3779	}
3780
3781	LOG_FUNCTION_NAME_EXIT;
3782	}
3783
3784	void CameraHal::resetPreviewRes(CameraParameters *mParams, int width, int height)
3785	{
3786	LOG_FUNCTION_NAME;
3787
3788	if ( (width <= 320) && (height <= 240)){
3789	mParams->setPreviewSize(mVideoWidth, mVideoHeight);
3790	}
3791
3792	LOG_FUNCTION_NAME_EXIT;
3793	}
3794
3795	};
3796
3797
3798