1 /*
2 Copyright (c) 2011-2012, Code Aurora Forum. All rights reserved.
3
4 Redistribution and use in source and binary forms, with or without
5 modification, are permitted provided that the following conditions are
6 met:
7 * Redistributions of source code must retain the above copyright
8 notice, this list of conditions and the following disclaimer.
9 * Redistributions in binary form must reproduce the above
10 copyright notice, this list of conditions and the following
11 disclaimer in the documentation and/or other materials provided
12 with the distribution.
13 * Neither the name of Code Aurora Forum, Inc. nor the names of its
14 contributors may be used to endorse or promote products derived
15 from this software without specific prior written permission.
16
17 THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
18 WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
19 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
20 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
21 BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
22 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
24 BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
25 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
26 OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
27 IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30 #include <pthread.h>
31 #include "mm_camera_dbg.h"
32 #include <errno.h>
33 #include <sys/ioctl.h>
34 #include <sys/types.h>
35 #include <sys/stat.h>
36 #include <fcntl.h>
37 #include <poll.h>
38 #include "mm_camera_sock.h"
39 #include "mm_camera_interface2.h"
40 #include "mm_camera.h"
41
42 static int32_t mm_camera_send_native_ctrl_cmd(mm_camera_obj_t * my_obj,
43 cam_ctrl_type type, uint32_t length, void *value);
44 static int32_t mm_camera_send_native_ctrl_timeout_cmd(mm_camera_obj_t * my_obj,
45 cam_ctrl_type type, uint32_t length, void *value, int timeout);
mm_camera_ctrl_set_specialEffect(mm_camera_obj_t * my_obj,int effect)46 static int32_t mm_camera_ctrl_set_specialEffect (mm_camera_obj_t *my_obj, int effect) {
47 struct v4l2_control ctrl;
48 if (effect == CAMERA_EFFECT_MAX)
49 effect = CAMERA_EFFECT_OFF;
50 int rc = 0;
51
52 ctrl.id = MSM_V4L2_PID_EFFECT;
53 ctrl.value = effect;
54 rc = ioctl(my_obj->ctrl_fd, VIDIOC_S_CTRL, &ctrl);
55 return rc;
56 }
57
mm_camera_ctrl_set_antibanding(mm_camera_obj_t * my_obj,int antibanding)58 static int32_t mm_camera_ctrl_set_antibanding (mm_camera_obj_t *my_obj, int antibanding) {
59 int rc = 0;
60 struct v4l2_control ctrl;
61
62 ctrl.id = V4L2_CID_POWER_LINE_FREQUENCY;
63 ctrl.value = antibanding;
64 rc = ioctl(my_obj->ctrl_fd, VIDIOC_S_CTRL, &ctrl);
65 return rc;
66 }
67
mm_camera_ctrl_set_auto_focus(mm_camera_obj_t * my_obj,int value)68 static int32_t mm_camera_ctrl_set_auto_focus (mm_camera_obj_t *my_obj, int value)
69 {
70 int rc = 0;
71 struct v4l2_queryctrl queryctrl;
72
73 memset (&queryctrl, 0, sizeof (queryctrl));
74 queryctrl.id = V4L2_CID_FOCUS_AUTO;
75
76 if(value != 0 && value != 1) {
77 CDBG("%s:boolean required, invalid value = %d\n",__func__, value);
78 return -MM_CAMERA_E_INVALID_INPUT;
79 }
80 if (-1 == ioctl (my_obj->ctrl_fd, VIDIOC_QUERYCTRL, &queryctrl)) {
81 CDBG ("V4L2_CID_FOCUS_AUTO is not supported\n");
82 } else if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) {
83 CDBG ("%s:V4L2_CID_FOCUS_AUTO is not supported\n", __func__);
84 } else {
85 if(0 != (rc = mm_camera_util_s_ctrl(my_obj->ctrl_fd,
86 V4L2_CID_FOCUS_AUTO, value))){
87 CDBG("%s: error, id=0x%x, value=%d, rc = %d\n",
88 __func__, V4L2_CID_FOCUS_AUTO, value, rc);
89 rc = -1;
90 }
91 }
92 return rc;
93 }
94
mm_camera_ctrl_set_whitebalance(mm_camera_obj_t * my_obj,int mode)95 static int32_t mm_camera_ctrl_set_whitebalance (mm_camera_obj_t *my_obj, int mode) {
96
97 int rc = 0, value;
98 uint32_t id;
99
100 switch(mode) {
101 case MM_CAMERA_WHITE_BALANCE_AUTO:
102 id = V4L2_CID_AUTO_WHITE_BALANCE;
103 value = 1; /* TRUE */
104 break;
105 case MM_CAMERA_WHITE_BALANCE_OFF:
106 id = V4L2_CID_AUTO_WHITE_BALANCE;
107 value = 0; /* FALSE */
108 break;
109 default:
110 id = V4L2_CID_WHITE_BALANCE_TEMPERATURE;
111 if(mode == WHITE_BALANCE_DAYLIGHT) value = 6500;
112 else if(mode == WHITE_BALANCE_INCANDESCENT) value = 2800;
113 else if(mode == WHITE_BALANCE_FLUORESCENT ) value = 4200;
114 else if(mode == WHITE_BALANCE_CLOUDY) value = 7500;
115 else
116 value = 4200;
117 }
118 if(0 != (rc = mm_camera_util_s_ctrl(my_obj->ctrl_fd,
119 id, value))){
120 CDBG("%s: error, exp_metering_action_param=%d, rc = %d\n", __func__, value, rc);
121 goto end;
122 }
123 end:
124 return rc;
125 }
126
mm_camera_ctrl_set_toggle_afr(mm_camera_obj_t * my_obj)127 static int32_t mm_camera_ctrl_set_toggle_afr (mm_camera_obj_t *my_obj) {
128 int rc = 0;
129 int value = 0;
130 if(0 != (rc = mm_camera_util_g_ctrl(my_obj->ctrl_fd,
131 V4L2_CID_EXPOSURE_AUTO, &value))){
132 goto end;
133 }
134 /* V4L2_CID_EXPOSURE_AUTO needs to be AUTO or SHUTTER_PRIORITY */
135 if (value != V4L2_EXPOSURE_AUTO && value != V4L2_EXPOSURE_SHUTTER_PRIORITY) {
136 CDBG("%s: V4L2_CID_EXPOSURE_AUTO needs to be AUTO/SHUTTER_PRIORITY\n",
137 __func__);
138 return -1;
139 }
140 if(0 != (rc = mm_camera_util_g_ctrl(my_obj->ctrl_fd,
141 V4L2_CID_EXPOSURE_AUTO_PRIORITY, &value))){
142 goto end;
143 }
144 value = !value;
145 if(0 != (rc = mm_camera_util_s_ctrl(my_obj->ctrl_fd,
146 V4L2_CID_EXPOSURE_AUTO_PRIORITY, value))){
147 goto end;
148 }
149 end:
150 return rc;
151 }
152
mm_camera_util_opcode_2_ch_type(mm_camera_obj_t * my_obj,mm_camera_ops_type_t opcode)153 static mm_camera_channel_type_t mm_camera_util_opcode_2_ch_type(
154 mm_camera_obj_t *my_obj,
155 mm_camera_ops_type_t opcode)
156 {
157 mm_camera_channel_type_t type = MM_CAMERA_CH_MAX;
158 switch(opcode) {
159 case MM_CAMERA_OPS_PREVIEW:
160 return MM_CAMERA_CH_PREVIEW;
161 case MM_CAMERA_OPS_VIDEO:
162 return MM_CAMERA_CH_VIDEO;
163 case MM_CAMERA_OPS_SNAPSHOT:
164 return MM_CAMERA_CH_SNAPSHOT;
165 case MM_CAMERA_OPS_PREPARE_SNAPSHOT:
166 return MM_CAMERA_CH_SNAPSHOT;
167 case MM_CAMERA_OPS_RAW:
168 return MM_CAMERA_CH_RAW;
169 case MM_CAMERA_OPS_ZSL:
170 return MM_CAMERA_CH_SNAPSHOT;
171 default:
172 break;
173 }
174 return type;
175 }
176
mm_camera_util_set_op_mode(mm_camera_obj_t * my_obj,mm_camera_op_mode_type_t * op_mode)177 static int32_t mm_camera_util_set_op_mode(mm_camera_obj_t * my_obj,
178 mm_camera_op_mode_type_t *op_mode)
179 {
180 int32_t rc = MM_CAMERA_OK;
181 uint32_t v4l2_op_mode = MSM_V4L2_CAM_OP_DEFAULT;
182
183 if (my_obj->op_mode == *op_mode)
184 goto end;
185 if(mm_camera_poll_busy(my_obj) == TRUE) {
186 CDBG("%s: cannot change op_mode while stream on\n", __func__);
187 rc = -MM_CAMERA_E_INVALID_OPERATION;
188 goto end;
189 }
190 switch(*op_mode) {
191 case MM_CAMERA_OP_MODE_ZSL:
192 v4l2_op_mode = MSM_V4L2_CAM_OP_ZSL;
193 break;
194 case MM_CAMERA_OP_MODE_CAPTURE:
195 v4l2_op_mode = MSM_V4L2_CAM_OP_CAPTURE;
196 break;
197 case MM_CAMERA_OP_MODE_VIDEO:
198 v4l2_op_mode = MSM_V4L2_CAM_OP_VIDEO;
199 break;
200 default:
201 rc = - MM_CAMERA_E_INVALID_INPUT;
202 goto end;
203 break;
204 }
205 if(0 != (rc = mm_camera_util_s_ctrl(my_obj->ctrl_fd,
206 MSM_V4L2_PID_CAM_MODE, v4l2_op_mode))){
207 CDBG("%s: input op_mode=%d, s_ctrl rc=%d\n", __func__, *op_mode, rc);
208 goto end;
209 }
210 /* if success update mode field */
211 my_obj->op_mode = *op_mode;
212 end:
213 CDBG("%s: op_mode=%d,rc=%d\n", __func__, *op_mode, rc);
214 return rc;
215 }
216
mm_camera_set_general_parm(mm_camera_obj_t * my_obj,mm_camera_parm_t * parm)217 int32_t mm_camera_set_general_parm(mm_camera_obj_t * my_obj, mm_camera_parm_t *parm)
218 {
219 int rc = -MM_CAMERA_E_NOT_SUPPORTED;
220 int isZSL =0;
221
222 switch(parm->parm_type) {
223 case MM_CAMERA_PARM_EXPOSURE:
224 return mm_camera_util_s_ctrl(my_obj->ctrl_fd,
225 MSM_V4L2_PID_EXP_METERING,
226 *((int *)(parm->p_value)));
227 case MM_CAMERA_PARM_SHARPNESS:
228 return mm_camera_util_s_ctrl(my_obj->ctrl_fd, V4L2_CID_SHARPNESS,
229 *((int *)(parm->p_value)));
230 case MM_CAMERA_PARM_CONTRAST:
231 return mm_camera_util_s_ctrl(my_obj->ctrl_fd, V4L2_CID_CONTRAST,
232 *((int *)(parm->p_value)));
233 case MM_CAMERA_PARM_SATURATION:
234 return mm_camera_util_s_ctrl(my_obj->ctrl_fd, V4L2_CID_SATURATION,
235 *((int *)(parm->p_value)));
236 case MM_CAMERA_PARM_BRIGHTNESS:
237 return mm_camera_util_s_ctrl(my_obj->ctrl_fd, V4L2_CID_BRIGHTNESS,
238 *((int *)(parm->p_value)));
239 case MM_CAMERA_PARM_WHITE_BALANCE:
240 return mm_camera_ctrl_set_whitebalance (my_obj, *((int *)(parm->p_value)));
241 case MM_CAMERA_PARM_ISO:
242 return mm_camera_util_s_ctrl(my_obj->ctrl_fd, MSM_V4L2_PID_ISO,
243 *((int *)(parm->p_value)));
244 case MM_CAMERA_PARM_ZOOM:
245 return mm_camera_util_s_ctrl(my_obj->ctrl_fd, V4L2_CID_ZOOM_ABSOLUTE,
246 *((int *)(parm->p_value)));
247 case MM_CAMERA_PARM_LUMA_ADAPTATION:
248 return mm_camera_util_s_ctrl(my_obj->ctrl_fd, MSM_V4L2_PID_LUMA_ADAPTATION,
249 *((int *)(parm->p_value)));
250 case MM_CAMERA_PARM_ANTIBANDING:
251 return mm_camera_ctrl_set_antibanding (my_obj, *((int *)(parm->p_value)));
252 case MM_CAMERA_PARM_CONTINUOUS_AF:
253 return mm_camera_ctrl_set_auto_focus(my_obj, *((int *)(parm->p_value)));
254 case MM_CAMERA_PARM_HJR:
255 return mm_camera_util_s_ctrl(my_obj->ctrl_fd, MSM_V4L2_PID_HJR, *((int *)(parm->p_value)));
256 case MM_CAMERA_PARM_EFFECT:
257 return mm_camera_ctrl_set_specialEffect (my_obj, *((int *)(parm->p_value)));
258 case MM_CAMERA_PARM_FPS:
259 return mm_camera_send_native_ctrl_cmd(my_obj,
260 CAMERA_SET_PARM_FPS, sizeof(uint32_t), (void *)parm->p_value);
261 case MM_CAMERA_PARM_FPS_MODE:
262 return mm_camera_send_native_ctrl_cmd(my_obj,
263 CAMERA_SET_FPS_MODE, sizeof(int32_t), (void *)parm->p_value);
264 case MM_CAMERA_PARM_EXPOSURE_COMPENSATION:
265 return mm_camera_send_native_ctrl_cmd(my_obj,
266 CAMERA_SET_PARM_EXPOSURE_COMPENSATION, sizeof(int32_t), (void *)parm->p_value);
267 case MM_CAMERA_PARM_LED_MODE:
268 return mm_camera_send_native_ctrl_cmd(my_obj,
269 CAMERA_SET_PARM_LED_MODE, sizeof(int32_t), (void *)parm->p_value);
270 case MM_CAMERA_PARM_ROLLOFF:
271 return mm_camera_send_native_ctrl_cmd(my_obj,
272 CAMERA_SET_PARM_ROLLOFF, sizeof(int32_t), (void *)parm->p_value);
273 case MM_CAMERA_PARM_MODE:
274 my_obj->current_mode = *((camera_mode_t *)parm->p_value);
275 break;
276 case MM_CAMERA_PARM_FOCUS_RECT:
277 return mm_camera_send_native_ctrl_cmd(my_obj,
278 CAMERA_SET_PARM_FOCUS_RECT, sizeof(int32_t), (void *)parm->p_value);
279 case MM_CAMERA_PARM_AEC_ROI:
280 return mm_camera_send_native_ctrl_cmd(my_obj,
281 CAMERA_SET_PARM_AEC_ROI, sizeof(cam_set_aec_roi_t), (void *)parm->p_value);
282 case MM_CAMERA_PARM_AF_ROI:
283 return mm_camera_send_native_ctrl_cmd(my_obj,
284 CAMERA_SET_PARM_AF_ROI, sizeof(roi_info_t), (void *)parm->p_value);
285 case MM_CAMERA_PARM_FOCUS_MODE:
286 return mm_camera_send_native_ctrl_cmd(my_obj,
287 CAMERA_SET_PARM_AF_MODE, sizeof(int32_t), (void *)parm->p_value);
288 #if 0 //to be enabled later: @punits
289 case MM_CAMERA_PARM_AF_MTR_AREA:
290 return mm_camera_send_native_ctrl_cmd(my_obj,
291 CAMERA_SET_PARM_AF_MTR_AREA, sizeof(af_mtr_area_t), (void *)parm->p_value);*/
292 case MM_CAMERA_PARM_AEC_MTR_AREA:
293 return mm_camera_send_native_ctrl_cmd(my_obj,
294 CAMERA_SET_AEC_MTR_AREA, sizeof(aec_mtr_area_t), (void *)parm->p_value);
295 #endif
296 case MM_CAMERA_PARM_CAF_ENABLE:
297 return mm_camera_send_native_ctrl_cmd(my_obj,
298 CAMERA_SET_PARM_CAF, sizeof(uint32_t), (void *)parm->p_value);
299 case MM_CAMERA_PARM_BESTSHOT_MODE:
300 CDBG("%s : MM_CAMERA_PARM_BESTSHOT_MODE value : %d",__func__,*((int *)(parm->p_value)));
301 return mm_camera_send_native_ctrl_cmd(my_obj,
302 CAMERA_SET_PARM_BESTSHOT_MODE, sizeof(int32_t), (void *)parm->p_value);
303 break;
304 case MM_CAMERA_PARM_VIDEO_DIS:
305 return mm_camera_send_native_ctrl_cmd(my_obj,
306 CAMERA_SET_VIDEO_DIS_PARAMS, sizeof(video_dis_param_ctrl_t), (void *)parm->p_value);
307 case MM_CAMERA_PARM_VIDEO_ROT:
308 return mm_camera_send_native_ctrl_cmd(my_obj,
309 CAMERA_SET_VIDEO_ROT_PARAMS, sizeof(video_rotation_param_ctrl_t), (void *)parm->p_value);
310 case MM_CAMERA_PARM_SCE_FACTOR:
311 return mm_camera_send_native_ctrl_cmd(my_obj,
312 CAMERA_SET_SCE_FACTOR, sizeof(int32_t), (void *)parm->p_value);
313 case MM_CAMERA_PARM_FD:
314 return mm_camera_send_native_ctrl_cmd(my_obj,
315 CAMERA_SET_PARM_FD, sizeof(fd_set_parm_t), (void *)parm->p_value);
316 case MM_CAMERA_PARM_AEC_LOCK:
317 return mm_camera_send_native_ctrl_cmd(my_obj,
318 CAMERA_SET_AEC_LOCK, sizeof(int32_t), (void *)parm->p_value);
319 case MM_CAMERA_PARM_AWB_LOCK:
320 return mm_camera_send_native_ctrl_cmd(my_obj, CAMERA_SET_AWB_LOCK,
321 sizeof(int32_t), (void *)parm->p_value);
322 case MM_CAMERA_PARM_MCE:
323 return mm_camera_send_native_ctrl_cmd(my_obj, CAMERA_SET_PARM_MCE,
324 sizeof(int32_t), (void *)parm->p_value);
325 case MM_CAMERA_PARM_HORIZONTAL_VIEW_ANGLE:
326 return mm_camera_send_native_ctrl_cmd(my_obj, CAMERA_GET_PARM_HORIZONTAL_VIEW_ANGLE,
327 sizeof(focus_distances_info_t), (void *)parm->p_value);
328 case MM_CAMERA_PARM_VERTICAL_VIEW_ANGLE:
329 return mm_camera_send_native_ctrl_cmd(my_obj, CAMERA_GET_PARM_VERTICAL_VIEW_ANGLE,
330 sizeof(focus_distances_info_t), (void *)parm->p_value);
331 case MM_CAMERA_PARM_RESET_LENS_TO_INFINITY:
332 return mm_camera_send_native_ctrl_cmd(my_obj,
333 CAMERA_SET_PARM_RESET_LENS_TO_INFINITY,
334 0, NULL);
335 case MM_CAMERA_PARM_SNAPSHOTDATA:
336 return mm_camera_send_native_ctrl_cmd(my_obj, CAMERA_GET_PARM_SNAPSHOTDATA,
337 sizeof(snapshotData_info_t), (void *)parm->p_value);
338 case MM_CAMERA_PARM_HFR:
339 return mm_camera_send_native_ctrl_cmd(my_obj,
340 CAMERA_SET_PARM_HFR, sizeof(int32_t), (void *)parm->p_value);
341 case MM_CAMERA_PARM_REDEYE_REDUCTION:
342 return mm_camera_send_native_ctrl_cmd(my_obj,
343 CAMERA_SET_REDEYE_REDUCTION, sizeof(int32_t), (void *)parm->p_value);
344 case MM_CAMERA_PARM_WAVELET_DENOISE:
345 return mm_camera_send_native_ctrl_cmd(my_obj,
346 CAMERA_SET_PARM_WAVELET_DENOISE, sizeof(denoise_param_t), (void *)parm->p_value);
347 case MM_CAMERA_PARM_3D_DISPLAY_DISTANCE:
348 return mm_camera_send_native_ctrl_cmd(my_obj,
349 CAMERA_SET_PARM_3D_DISPLAY_DISTANCE, sizeof(float), (void *)parm->p_value);
350 case MM_CAMERA_PARM_3D_VIEW_ANGLE:
351 return mm_camera_send_native_ctrl_cmd(my_obj,
352 CAMERA_SET_PARM_3D_VIEW_ANGLE, sizeof(uint32_t), (void *)parm->p_value);
353 case MM_CAMERA_PARM_ZOOM_RATIO:
354 break;
355 case MM_CAMERA_PARM_HISTOGRAM:
356 return mm_camera_send_native_ctrl_cmd(my_obj,
357 CAMERA_SET_PARM_HISTOGRAM, sizeof(int8_t), (void *)parm->p_value);
358 case MM_CAMERA_PARM_JPEG_ROTATION:
359 if(my_obj->op_mode == MM_CAMERA_OP_MODE_ZSL){
360 isZSL =1;
361 }
362 mm_jpeg_encoder_setRotation(*((int *)parm->p_value),isZSL);
363 return MM_CAMERA_OK;
364
365 case MM_CAMERA_PARM_ASD_ENABLE:
366 return mm_camera_send_native_ctrl_cmd(my_obj,
367 CAMERA_SET_ASD_ENABLE, sizeof(uint32_t), (void *)parm->p_value);
368
369 case MM_CAMERA_PARM_RECORDING_HINT:
370 return mm_camera_send_native_ctrl_cmd(my_obj,
371 CAMERA_SET_RECORDING_HINT, sizeof(uint32_t), (void *)parm->p_value);
372
373 case MM_CAMERA_PARM_PREVIEW_FORMAT:
374 return mm_camera_send_native_ctrl_cmd(my_obj,
375 CAMERA_SET_PARM_PREVIEW_FORMAT, sizeof(uint32_t), (void *)parm->p_value);
376
377 case MM_CAMERA_PARM_DIS_ENABLE:
378 return mm_camera_send_native_ctrl_cmd(my_obj,
379 CAMERA_SET_DIS_ENABLE, sizeof(uint32_t), (void *)parm->p_value);
380
381 case MM_CAMERA_PARM_FULL_LIVESHOT: {
382 my_obj->full_liveshot = *((int *)(parm->p_value));
383 return mm_camera_send_native_ctrl_cmd(my_obj,
384 CAMERA_SET_FULL_LIVESHOT, sizeof(uint32_t), (void *)parm->p_value);
385 }
386
387 case MM_CAMERA_PARM_LOW_POWER_MODE:
388 return mm_camera_send_native_ctrl_cmd(my_obj,
389 CAMERA_SET_LOW_POWER_MODE, sizeof(uint32_t), (void *)parm->p_value);
390
391 #ifdef FAST_AF
392 case MM_CAMERA_PARM_CAF_TYPE:
393 CDBG("SM : %s : MM_CAMERA_PARM_CAF_TYPE value : %d",__func__,*((int *)(parm->p_value)));
394 return mm_camera_send_native_ctrl_cmd(my_obj,
395 CAMERA_SET_PARM_CAF_TYPE, sizeof(int32_t), (void *)parm->p_value);
396 #endif
397 case MM_CAMERA_PARM_HDR:
398 return mm_camera_send_native_ctrl_cmd(my_obj,
399 CAMERA_SET_PARM_HDR, sizeof(exp_bracketing_t), (void *)parm->p_value);
400
401 case MM_CAMERA_PARM_CAF_LOCK_CANCEL:
402 return mm_camera_send_native_ctrl_cmd(my_obj,
403 CAMERA_SET_CAF_LOCK_CANCEL, sizeof(uint32_t), (void *)parm->p_value);
404
405 default:
406 CDBG("%s: default: parm %d not supported\n", __func__, parm->parm_type);
407 break;
408 }
409 return rc;
410 }
mm_camera_send_native_ctrl_cmd(mm_camera_obj_t * my_obj,cam_ctrl_type type,uint32_t length,void * value)411 static int32_t mm_camera_send_native_ctrl_cmd(mm_camera_obj_t * my_obj,
412 cam_ctrl_type type, uint32_t length, void *value)
413 {
414 int rc = -1;
415 struct msm_ctrl_cmd ctrl_cmd;
416 memset(&ctrl_cmd, 0, sizeof(ctrl_cmd));
417 ctrl_cmd.type = type;
418 ctrl_cmd.length = (uint16_t)length;
419 ctrl_cmd.timeout_ms = 1000;
420 ctrl_cmd.value = value;
421 ctrl_cmd.status = CAM_CTRL_SUCCESS;
422 rc = mm_camera_util_private_s_ctrl(my_obj->ctrl_fd, MSM_V4L2_PID_CTRL_CMD,
423 (int)&ctrl_cmd);
424 CDBG("%s: type=%d, rc = %d, status = %d\n",
425 __func__, type, rc, ctrl_cmd.status);
426
427 if(rc != MM_CAMERA_OK || ((ctrl_cmd.status != CAM_CTRL_ACCEPTED) &&
428 (ctrl_cmd.status != CAM_CTRL_SUCCESS) &&
429 (ctrl_cmd.status != CAM_CTRL_INVALID_PARM)))
430 rc = -1;
431 return rc;
432 }
433
mm_camera_send_native_ctrl_timeout_cmd(mm_camera_obj_t * my_obj,cam_ctrl_type type,uint32_t length,void * value,int timeout)434 static int32_t mm_camera_send_native_ctrl_timeout_cmd(mm_camera_obj_t * my_obj,
435 cam_ctrl_type type, uint32_t length, void *value,int timeout)
436 {
437 int rc = -1;
438 struct msm_ctrl_cmd ctrl_cmd;
439 memset(&ctrl_cmd, 0, sizeof(ctrl_cmd));
440 ctrl_cmd.type = type;
441 ctrl_cmd.length = (uint16_t)length;
442 ctrl_cmd.timeout_ms = timeout;
443 ctrl_cmd.value = value;
444 ctrl_cmd.status = CAM_CTRL_SUCCESS;
445 rc = mm_camera_util_private_s_ctrl(my_obj->ctrl_fd, MSM_V4L2_PID_CTRL_CMD,
446 (int)&ctrl_cmd);
447 CDBG("%s: type=%d, rc = %d, status = %d\n",
448 __func__, type, rc, ctrl_cmd.status);
449 if(rc != MM_CAMERA_OK || ((ctrl_cmd.status != CAM_CTRL_ACCEPTED) &&
450 (ctrl_cmd.status != CAM_CTRL_SUCCESS) &&
451 (ctrl_cmd.status != CAM_CTRL_INVALID_PARM)))
452 rc = -1;
453 return rc;
454 }
455
mm_camera_set_parm(mm_camera_obj_t * my_obj,mm_camera_parm_t * parm)456 int32_t mm_camera_set_parm(mm_camera_obj_t * my_obj,
457 mm_camera_parm_t *parm)
458 {
459 int32_t rc = -1;
460 uint16_t len;
461 CDBG("%s type =%d", __func__, parm->parm_type);
462 switch(parm->parm_type) {
463 case MM_CAMERA_PARM_OP_MODE:
464 rc = mm_camera_util_set_op_mode(my_obj,
465 (mm_camera_op_mode_type_t *)parm->p_value);
466 break;
467 case MM_CAMERA_PARM_DIMENSION:
468 rc = mm_camera_send_native_ctrl_cmd(my_obj,
469 CAMERA_SET_PARM_DIMENSION, sizeof(cam_ctrl_dimension_t), parm->p_value);
470 if(rc != MM_CAMERA_OK) {
471 CDBG("%s: mm_camera_send_native_ctrl_cmd err=%d\n", __func__, rc);
472 break;
473 }
474 memcpy(&my_obj->dim, (cam_ctrl_dimension_t *)parm->p_value,
475 sizeof(cam_ctrl_dimension_t));
476 CDBG("%s: dw=%d,dh=%d,vw=%d,vh=%d,pw=%d,ph=%d,tw=%d,th=%d,raw_w=%d,raw_h=%d\n",
477 __func__,
478 my_obj->dim.display_width,my_obj->dim.display_height,
479 my_obj->dim.video_width, my_obj->dim.video_height,
480 my_obj->dim.picture_width,my_obj->dim.picture_height,
481 my_obj->dim.ui_thumbnail_width,my_obj->dim.ui_thumbnail_height,
482 my_obj->dim.raw_picture_width,my_obj->dim.raw_picture_height);
483 break;
484 case MM_CAMERA_PARM_SNAPSHOT_BURST_NUM:
485 CDBG("%s: Setting snapshot burst number: %d\n", __func__, *((int *)parm->p_value));
486 my_obj->snap_burst_num_by_user = *((int *)parm->p_value);
487 rc = MM_CAMERA_OK;
488 break;
489 case MM_CAMERA_PARM_CH_IMAGE_FMT:
490 {
491 mm_camera_ch_image_fmt_parm_t *fmt;
492 fmt = (mm_camera_ch_image_fmt_parm_t *)parm->p_value;
493 rc = mm_camera_ch_fn(my_obj, fmt->ch_type,
494 MM_CAMERA_STATE_EVT_SET_FMT, fmt);
495 }
496 break;
497 case MM_CAMERA_PARM_CHECK_AF_RETRY:
498 return mm_camera_send_native_ctrl_cmd(my_obj, CAMERA_CHECK_AF_RETRY,
499 0, (void *)NULL);
500 case MM_CAMERA_PARM_LG_CAF_LOCK:
501 return mm_camera_send_native_ctrl_cmd(my_obj, CAMERA_SET_LG_CAF_LOCK,
502 0, (void *)NULL);
503 case MM_CAMERA_PARM_INFORM_STARTPRVIEW:
504 return mm_camera_send_native_ctrl_cmd(my_obj, CAMERA_SET_INFORM_STARTPREVIEW,
505 0, (void *)NULL);
506 default:
507 rc = mm_camera_set_general_parm(my_obj, parm);
508 break;
509 }
510 return rc;
511 }
512
mm_camera_get_parm(mm_camera_obj_t * my_obj,mm_camera_parm_t * parm)513 int32_t mm_camera_get_parm(mm_camera_obj_t * my_obj,
514 mm_camera_parm_t *parm)
515 {
516 int32_t rc = MM_CAMERA_OK;
517
518 switch(parm->parm_type) {
519 case MM_CAMERA_PARM_CROP:
520 return rc = mm_camera_ch_fn(my_obj,
521 ((mm_camera_ch_crop_t *)parm->p_value)->ch_type,
522 MM_CAMERA_STATE_EVT_GET_CROP, parm->p_value);
523 break;
524 case MM_CAMERA_PARM_DIMENSION:
525 memcpy(parm->p_value, &my_obj->dim, sizeof(my_obj->dim));
526 CDBG("%s: dw=%d,dh=%d,vw=%d,vh=%d,pw=%d,ph=%d,tw=%d,th=%d,ovx=%x,ovy=%d,opx=%d,opy=%d, m_fmt=%d, t_ftm=%d\n",
527 __func__,
528 my_obj->dim.display_width,my_obj->dim.display_height,
529 my_obj->dim.video_width,my_obj->dim.video_height,
530 my_obj->dim.picture_width,my_obj->dim.picture_height,
531 my_obj->dim.ui_thumbnail_width,my_obj->dim.ui_thumbnail_height,
532 my_obj->dim.orig_video_width,my_obj->dim.orig_video_height,
533 my_obj->dim.orig_picture_width,my_obj->dim.orig_picture_height,
534 my_obj->dim.main_img_format, my_obj->dim.thumb_format);
535 break;
536 case MM_CAMERA_PARM_MAX_PICTURE_SIZE: {
537 mm_camera_dimension_t *dim =
538 (mm_camera_dimension_t *)parm->p_value;
539 dim->height = my_obj->properties.max_pict_height;
540 dim->width = my_obj->properties.max_pict_width;
541 CDBG("%s: Max Picture Size: %d X %d\n", __func__,
542 dim->width, dim->height);
543 }
544 break;
545 case MM_CAMERA_PARM_RAW_SNAPSHOT_FMT:
546 *((cam_format_t *)parm->p_value) = my_obj->properties.pxlcode;
547 break;
548 case MM_CAMERA_PARM_PREVIEW_FORMAT:
549 *((int *)parm->p_value) = my_obj->properties.preview_format;
550 break;
551 case MM_CAMERA_PARM_PREVIEW_SIZES_CNT:
552 *((int *)parm->p_value) = my_obj->properties.preview_sizes_cnt;
553 break;
554 case MM_CAMERA_PARM_VIDEO_SIZES_CNT:
555 *((int *)parm->p_value) = my_obj->properties.video_sizes_cnt;
556 break;
557 case MM_CAMERA_PARM_THUMB_SIZES_CNT:
558 *((int *)parm->p_value) = my_obj->properties.thumb_sizes_cnt;
559 break;
560 case MM_CAMERA_PARM_HFR_SIZES_CNT:
561 *((int *)parm->p_value) = my_obj->properties.hfr_sizes_cnt;
562 break;
563 case MM_CAMERA_PARM_HFR_FRAME_SKIP:
564 *((int *)parm->p_value) = my_obj->properties.hfr_frame_skip;
565 break;
566 case MM_CAMERA_PARM_DEFAULT_PREVIEW_WIDTH:
567 *((int *)parm->p_value) = my_obj->properties.default_preview_width;
568 break;
569 case MM_CAMERA_PARM_DEFAULT_PREVIEW_HEIGHT:
570 *((int *)parm->p_value) = my_obj->properties.default_preview_height;
571 break;
572 case MM_CAMERA_PARM_BESTSHOT_RECONFIGURE:
573 *((int *)parm->p_value) = my_obj->properties.bestshot_reconfigure;
574 break;
575 case MM_CAMERA_PARM_MAX_PREVIEW_SIZE: {
576 mm_camera_dimension_t *dim =
577 (mm_camera_dimension_t *)parm->p_value;
578 dim->height = my_obj->properties.max_preview_height;
579 dim->width = my_obj->properties.max_preview_width;
580 CDBG("%s: Max Preview Size: %d X %d\n", __func__,
581 dim->width, dim->height);
582 }
583 break;
584 case MM_CAMERA_PARM_MAX_VIDEO_SIZE: {
585 mm_camera_dimension_t *dim =
586 (mm_camera_dimension_t *)parm->p_value;
587 dim->height = my_obj->properties.max_video_height;
588 dim->width = my_obj->properties.max_video_width;
589 CDBG("%s: Max Video Size: %d X %d\n", __func__,
590 dim->width, dim->height);
591 }
592 break;
593 case MM_CAMERA_PARM_MAX_HFR_MODE:
594 return mm_camera_send_native_ctrl_cmd(my_obj, CAMERA_GET_PARM_MAX_HFR_MODE,
595 sizeof(camera_hfr_mode_t), (void *)parm->p_value);
596 case MM_CAMERA_PARM_FOCAL_LENGTH:
597 return mm_camera_send_native_ctrl_cmd(my_obj, CAMERA_GET_PARM_FOCAL_LENGTH,
598 sizeof(focus_distances_info_t), (void *)parm->p_value);
599 case MM_CAMERA_PARM_HORIZONTAL_VIEW_ANGLE:
600 return mm_camera_send_native_ctrl_cmd(my_obj, CAMERA_GET_PARM_HORIZONTAL_VIEW_ANGLE,
601 sizeof(focus_distances_info_t), (void *)parm->p_value);
602 case MM_CAMERA_PARM_VERTICAL_VIEW_ANGLE:
603 return mm_camera_send_native_ctrl_cmd(my_obj, CAMERA_GET_PARM_VERTICAL_VIEW_ANGLE,
604 sizeof(focus_distances_info_t), (void *)parm->p_value);
605 case MM_CAMERA_PARM_FOCUS_DISTANCES:
606 return mm_camera_send_native_ctrl_cmd(my_obj, CAMERA_GET_PARM_FOCUS_DISTANCES,
607 sizeof(focus_distances_info_t), (void *)parm->p_value);
608 case MM_CAMERA_PARM_QUERY_FALSH4SNAP:
609 return mm_camera_send_native_ctrl_cmd(my_obj, CAMERA_QUERY_FLASH_FOR_SNAPSHOT,
610 sizeof(int), (void *)parm->p_value);
611 case MM_CAMERA_PARM_3D_FRAME_FORMAT:
612 return mm_camera_send_native_ctrl_cmd(my_obj, CAMERA_GET_PARM_3D_FRAME_FORMAT,
613 sizeof(camera_3d_frame_t), (void *)parm->p_value);
614 case MM_CAMERA_PARM_MAXZOOM:
615 return mm_camera_send_native_ctrl_cmd(my_obj, CAMERA_GET_PARM_MAXZOOM,
616 sizeof(int), (void *)parm->p_value);
617 case MM_CAMERA_PARM_ZOOM_RATIO: {
618 mm_camera_zoom_tbl_t *tbl = (mm_camera_zoom_tbl_t *)parm->p_value;
619 return mm_camera_send_native_ctrl_cmd(my_obj, CAMERA_GET_PARM_ZOOMRATIOS,
620 sizeof(int16_t)*tbl->size, tbl->zoom_ratio_tbl);
621 }
622 case MM_CAMERA_PARM_DEF_PREVIEW_SIZES: {
623 default_sizes_tbl_t *tbl = (default_sizes_tbl_t*)parm->p_value;
624 return mm_camera_send_native_ctrl_cmd(my_obj, CAMERA_GET_PARM_DEF_PREVIEW_SIZES,
625 sizeof(struct camera_size_type)*tbl->tbl_size, tbl->sizes_tbl);
626 }
627 case MM_CAMERA_PARM_DEF_VIDEO_SIZES: {
628 default_sizes_tbl_t *tbl = (default_sizes_tbl_t*)parm->p_value;
629 return mm_camera_send_native_ctrl_cmd(my_obj, CAMERA_GET_PARM_DEF_VIDEO_SIZES,
630 sizeof(struct camera_size_type)*tbl->tbl_size, tbl->sizes_tbl);
631 }
632 case MM_CAMERA_PARM_DEF_THUMB_SIZES: {
633 default_sizes_tbl_t *tbl = (default_sizes_tbl_t*)parm->p_value;
634 return mm_camera_send_native_ctrl_cmd(my_obj, CAMERA_GET_PARM_DEF_THUMB_SIZES,
635 sizeof(struct camera_size_type)*tbl->tbl_size, tbl->sizes_tbl);
636 }
637 case MM_CAMERA_PARM_DEF_HFR_SIZES:{
638 default_sizes_tbl_t *tbl = (default_sizes_tbl_t*)parm->p_value;
639 return mm_camera_send_native_ctrl_cmd(my_obj, CAMERA_GET_PARM_DEF_HFR_SIZES,
640 sizeof(struct camera_size_type)*tbl->tbl_size, tbl->sizes_tbl);
641 }
642 case MM_CAMERA_PARM_OP_MODE:
643 *((mm_camera_op_mode_type_t *)parm->p_value) = my_obj->op_mode;
644 break;
645 case MM_CAMERA_PARM_SNAPSHOT_BURST_NUM:
646 *((int *)parm->p_value) = my_obj->snap_burst_num_by_user;
647 break;
648 case MM_CAMERA_PARM_VFE_OUTPUT_ENABLE:
649 *((int *)parm->p_value) = my_obj->properties.vfe_output_enable;
650 break;
651 case MM_CAMERA_PARM_LUX_IDX:
652 CDBG("%s: MM_CAMERA_PARM_LUX_IDX\n", __func__);
653 return mm_camera_send_native_ctrl_cmd(my_obj, CAMERA_GET_PARM_LUX_IDX,
654 sizeof(int), (void *)parm->p_value);
655 case MM_CAMERA_PARM_MAX_NUM_FACES_DECT:
656 return mm_camera_send_native_ctrl_cmd(my_obj, CAMERA_GET_MAX_NUM_FACES_DECT,
657 sizeof(int), (void *)parm->p_value);
658 case MM_CAMERA_PARM_FACIAL_FEATURE_INFO:
659 return mm_camera_send_native_ctrl_cmd(my_obj, CAMERA_GET_FACIAL_FEATURE_INFO,
660 sizeof(int), (void *)parm->p_value);
661 case MM_CAMERA_PARM_HDR:
662 rc = mm_camera_send_native_ctrl_cmd(my_obj,
663 CAMERA_GET_PARM_HDR, sizeof(exp_bracketing_t), (void *)parm->p_value);
664 //my_obj->channel_interface_mask = *((exp_bracketing_t *)(parm->p_value));
665 break;
666 case MM_CAMERA_GET_PARM_LOW_LIGHT_FOR_ZSL:
667 return mm_camera_send_native_ctrl_cmd(my_obj, CAMERA_GET_PARM_LOW_LIGHT_FOR_ZSL,
668 sizeof(aec_info_for_flash_t), (void *)parm->p_value);
669
670 case MM_CAMERA_PARM_GET_AF_STATUS:
671 return mm_camera_send_native_ctrl_cmd(my_obj, CAMERA_GET_PARM_AF_STATUS,
672 sizeof(af_actuator_status_t), (void *)parm->p_value);
673 default:
674 /* needs to add more implementation */
675 rc = -1;
676 break;
677 }
678 return rc;
679 }
680
mm_camera_request_buf(mm_camera_obj_t * my_obj,mm_camera_reg_buf_t * buf)681 int32_t mm_camera_request_buf(mm_camera_obj_t * my_obj, mm_camera_reg_buf_t *buf)
682 {
683 int32_t rc = -MM_CAMERA_E_GENERAL;
684 rc = mm_camera_ch_fn(my_obj, buf->ch_type,
685 MM_CAMERA_STATE_EVT_REQUEST_BUF, (void *)&buf->preview);
686 return rc;
687 }
688
mm_camera_enqueue_buf(mm_camera_obj_t * my_obj,mm_camera_reg_buf_t * buf)689 int32_t mm_camera_enqueue_buf(mm_camera_obj_t * my_obj, mm_camera_reg_buf_t *buf)
690 {
691 int32_t rc = -MM_CAMERA_E_GENERAL;
692 rc = mm_camera_ch_fn(my_obj, buf->ch_type,
693 MM_CAMERA_STATE_EVT_ENQUEUE_BUF, (void *)&buf->preview);
694 return rc;
695 }
696
mm_camera_prepare_buf(mm_camera_obj_t * my_obj,mm_camera_reg_buf_t * buf)697 int32_t mm_camera_prepare_buf(mm_camera_obj_t * my_obj, mm_camera_reg_buf_t *buf)
698 {
699 int32_t rc = -MM_CAMERA_E_GENERAL;
700 rc = mm_camera_ch_fn(my_obj, buf->ch_type,
701 MM_CAMERA_STATE_EVT_REG_BUF, (void *)&buf->preview);
702 return rc;
703 }
mm_camera_unprepare_buf(mm_camera_obj_t * my_obj,mm_camera_channel_type_t ch_type)704 int32_t mm_camera_unprepare_buf(mm_camera_obj_t * my_obj, mm_camera_channel_type_t ch_type)
705 {
706 int32_t rc = -MM_CAMERA_E_GENERAL;
707 pthread_mutex_lock(&my_obj->ch[ch_type].mutex);
708 rc = mm_camera_ch_fn(my_obj, ch_type,
709 MM_CAMERA_STATE_EVT_UNREG_BUF, NULL);
710 pthread_mutex_unlock(&my_obj->ch[ch_type].mutex);
711 return rc;
712 }
713
mm_camera_evt_sub(mm_camera_obj_t * my_obj,mm_camera_event_type_t evt_type,int reg_count)714 static int mm_camera_evt_sub(mm_camera_obj_t * my_obj,
715 mm_camera_event_type_t evt_type, int reg_count)
716 {
717 int rc = MM_CAMERA_OK;
718 struct v4l2_event_subscription sub;
719
720 memset(&sub, 0, sizeof(sub));
721 sub.type = V4L2_EVENT_PRIVATE_START+MSM_CAM_APP_NOTIFY_EVENT;
722 if(reg_count == 0) {
723 /* unsubscribe */
724 if(my_obj->evt_type_mask == (uint32_t)(1 << evt_type)) {
725 rc = ioctl(my_obj->ctrl_fd, VIDIOC_UNSUBSCRIBE_EVENT, &sub);
726 CDBG("%s: unsubscribe event 0x%x, rc = %d", __func__, sub.type, rc);
727 sub.type = V4L2_EVENT_PRIVATE_START+MSM_CAM_APP_NOTIFY_ERROR_EVENT;
728 rc = ioctl(my_obj->ctrl_fd, VIDIOC_UNSUBSCRIBE_EVENT, &sub);
729 CDBG("%s: unsubscribe event 0x%x, rc = %d", __func__, sub.type, rc);
730 }
731 my_obj->evt_type_mask &= ~(1 << evt_type);
732 if(my_obj->evt_type_mask == 0) {
733 /* kill the polling thraed when unreg the last event */
734 mm_camera_poll_thread_release(my_obj, MM_CAMERA_CH_MAX);
735 }
736 } else {
737 if(!my_obj->evt_type_mask) {
738 /* this is the first reg event */
739 rc = ioctl(my_obj->ctrl_fd, VIDIOC_SUBSCRIBE_EVENT, &sub);
740 CDBG("%s: subscribe event 0x%x, rc = %d", __func__, sub.type, rc);
741 if (rc < 0)
742 goto end;
743 sub.type = V4L2_EVENT_PRIVATE_START+MSM_CAM_APP_NOTIFY_ERROR_EVENT;
744 rc = ioctl(my_obj->ctrl_fd, VIDIOC_SUBSCRIBE_EVENT, &sub);
745 CDBG("%s: subscribe event 0x%x, rc = %d", __func__, sub.type, rc);
746 if (rc < 0)
747 goto end;
748 }
749 my_obj->evt_type_mask |= (1 << evt_type);
750 if(my_obj->evt_type_mask == (uint32_t)(1 << evt_type)) {
751 /* launch event polling when subscribe the first event */
752 rc = mm_camera_poll_thread_launch(my_obj, MM_CAMERA_CH_MAX);
753 }
754 }
755 end:
756 return rc;
757 }
758
mm_camera_reg_event(mm_camera_obj_t * my_obj,mm_camera_event_notify_t evt_cb,void * user_data,mm_camera_event_type_t evt_type)759 int mm_camera_reg_event(mm_camera_obj_t * my_obj, mm_camera_event_notify_t evt_cb,
760 void *user_data, mm_camera_event_type_t evt_type)
761 {
762 int i;
763 int rc = -1;
764 mm_camera_evt_obj_t *evt_array = &my_obj->evt[evt_type];
765 if(evt_cb) {
766 /* this is reg case */
767 for(i = 0; i < MM_CAMERA_EVT_ENTRY_MAX; i++) {
768 if(evt_array->evt[i].user_data == NULL) {
769 evt_array->evt[i].evt_cb = evt_cb;
770 evt_array->evt[i].user_data = user_data;
771 evt_array->reg_count++;
772 rc = MM_CAMERA_OK;
773 break;
774 }
775 }
776 } else {
777 /* this is unreg case */
778 for(i = 0; i < MM_CAMERA_EVT_ENTRY_MAX; i++) {
779 if(evt_array->evt[i].user_data == user_data) {
780 evt_array->evt[i].evt_cb = NULL;
781 evt_array->evt[i].user_data = NULL;
782 evt_array->reg_count--;
783 rc = MM_CAMERA_OK;
784 break;
785 }
786 }
787 }
788 if(rc == MM_CAMERA_OK && evt_array->reg_count <= 1) {
789 /* subscribe/unsubscribe event to kernel */
790 rc = mm_camera_evt_sub(my_obj, evt_type, evt_array->reg_count);
791 }
792 return rc;
793 }
794
795
mm_camera_send_af_failed_event(mm_camera_obj_t * my_obj)796 static int32_t mm_camera_send_af_failed_event(mm_camera_obj_t *my_obj)
797 {
798 int rc = 0;
799 mm_camera_event_t event;
800 event.event_type = MM_CAMERA_EVT_TYPE_CTRL;
801 event.e.ctrl.evt= MM_CAMERA_CTRL_EVT_AUTO_FOCUS_DONE;
802 event.e.ctrl.status=CAM_CTRL_FAILED;
803 CDBG_HIGH("%s: Issuing call",__func__);
804 rc = mm_camera_poll_send_ch_event(my_obj, &event);
805 return rc;
806 }
807
mm_camera_send_ch_on_off_event(mm_camera_obj_t * my_obj,mm_camera_channel_type_t ch_type,mm_camera_ch_event_type_t evt)808 static int32_t mm_camera_send_ch_on_off_event(mm_camera_obj_t *my_obj,
809 mm_camera_channel_type_t ch_type,
810 mm_camera_ch_event_type_t evt)
811 {
812 int rc = 0;
813 mm_camera_event_t event;
814 event.event_type = MM_CAMERA_EVT_TYPE_CH;
815 event.e.ch.evt = evt;
816 event.e.ch.ch = ch_type;
817 CDBG("%s: stream on event, type=0x%x, ch=%d, evt=%d",
818 __func__, event.event_type, event.e.ch.ch, event.e.ch.evt);
819 rc = mm_camera_poll_send_ch_event(my_obj, &event);
820 return rc;
821 }
822
mm_camera_action_start(mm_camera_obj_t * my_obj,mm_camera_ops_type_t opcode,void * parm)823 int32_t mm_camera_action_start(mm_camera_obj_t *my_obj,
824 mm_camera_ops_type_t opcode, void *parm)
825 {
826 int32_t rc = -MM_CAMERA_E_GENERAL;
827 int send_on_off_evt = 1;
828 mm_camera_channel_type_t ch_type;
829 switch(opcode) {
830 case MM_CAMERA_OPS_FOCUS: {
831 if(!parm) return rc;
832 if(0 > mm_camera_send_native_ctrl_cmd(my_obj,
833 CAMERA_SET_PARM_AUTO_FOCUS,
834 sizeof(isp3a_af_mode_t), parm))
835 mm_camera_send_af_failed_event(my_obj);
836 return MM_CAMERA_OK;
837 }
838 case MM_CAMERA_OPS_GET_BUFFERED_FRAME: {
839 mm_camera_ops_parm_get_buffered_frame_t *tmp =
840 (mm_camera_ops_parm_get_buffered_frame_t *)parm;
841 rc = mm_camera_ch_fn(my_obj, tmp->ch_type,
842 MM_CAMERA_STATE_EVT_DISPATCH_BUFFERED_FRAME, NULL);
843 return rc;
844 }
845 default:
846 break;
847 }
848 ch_type = mm_camera_util_opcode_2_ch_type(my_obj, opcode);
849 CDBG("%s:ch=%d,op_mode=%d,opcode=%d\n",
850 __func__,ch_type,my_obj->op_mode,opcode);
851 switch(my_obj->op_mode) {
852 case MM_CAMERA_OP_MODE_ZSL:
853 case MM_CAMERA_OP_MODE_CAPTURE:
854 switch(opcode) {
855 case MM_CAMERA_OPS_PREVIEW:
856 case MM_CAMERA_OPS_SNAPSHOT:
857 case MM_CAMERA_OPS_ZSL:
858 case MM_CAMERA_OPS_RAW:
859 rc = mm_camera_ch_fn(my_obj, ch_type,
860 MM_CAMERA_STATE_EVT_STREAM_ON, NULL);
861 break;
862 default:
863 break;
864 }
865 break;
866 case MM_CAMERA_OP_MODE_VIDEO:
867 switch(opcode) {
868 case MM_CAMERA_OPS_PREVIEW:
869 case MM_CAMERA_OPS_VIDEO:
870 case MM_CAMERA_OPS_SNAPSHOT:
871 rc = mm_camera_ch_fn(my_obj, ch_type,
872 MM_CAMERA_STATE_EVT_STREAM_ON, NULL);
873 CDBG("%s: op_mode=%d, ch %d, rc=%d\n",
874 __func__, MM_CAMERA_OP_MODE_VIDEO, ch_type ,rc);
875 break;
876 case MM_CAMERA_OPS_PREPARE_SNAPSHOT:
877 send_on_off_evt = 0;
878 rc = mm_camera_send_native_ctrl_timeout_cmd(my_obj,CAMERA_PREPARE_SNAPSHOT, 0, NULL, 2000);
879 CDBG("%s: prepare snapshot done opcode = %d, rc= %d\n", __func__, opcode, rc);
880 break;
881 default:
882 break;
883 }
884 break;
885 default:
886 break;
887 }
888 CDBG("%s: ch=%d,op_mode=%d,opcode=%d\n", __func__, ch_type,
889 my_obj->op_mode, opcode);
890 if(send_on_off_evt)
891 rc = mm_camera_send_ch_on_off_event(my_obj,ch_type,MM_CAMERA_CH_EVT_STREAMING_ON);
892 return rc;
893 }
894
mm_camera_action_stop(mm_camera_obj_t * my_obj,mm_camera_ops_type_t opcode,void * parm)895 int32_t mm_camera_action_stop(mm_camera_obj_t *my_obj,
896 mm_camera_ops_type_t opcode, void *parm)
897 {
898 int32_t rc = -MM_CAMERA_E_GENERAL;
899 mm_camera_channel_type_t ch_type;
900
901 if(opcode == MM_CAMERA_OPS_FOCUS) {
902 return mm_camera_send_native_ctrl_cmd(my_obj,
903 CAMERA_AUTO_FOCUS_CANCEL, 0, NULL);
904 }
905
906 ch_type = mm_camera_util_opcode_2_ch_type(my_obj, opcode);
907 switch(my_obj->op_mode) {
908 case MM_CAMERA_OP_MODE_ZSL:
909 case MM_CAMERA_OP_MODE_CAPTURE:
910 switch(opcode) {
911 case MM_CAMERA_OPS_PREVIEW:
912 case MM_CAMERA_OPS_SNAPSHOT:
913 case MM_CAMERA_OPS_ZSL:
914 case MM_CAMERA_OPS_RAW:
915 rc = mm_camera_ch_fn(my_obj, ch_type,
916 MM_CAMERA_STATE_EVT_STREAM_OFF, NULL);
917 CDBG("%s:CAPTURE mode STREAMOFF rc=%d\n",__func__, rc);
918 break;
919 default:
920 break;
921 }
922 break;
923 case MM_CAMERA_OP_MODE_VIDEO:
924 switch(opcode) {
925 case MM_CAMERA_OPS_PREVIEW:
926 case MM_CAMERA_OPS_VIDEO:
927 case MM_CAMERA_OPS_SNAPSHOT:
928 rc = mm_camera_ch_fn(my_obj , ch_type,
929 MM_CAMERA_STATE_EVT_STREAM_OFF, NULL);
930 CDBG("%s:VIDEO mode STREAMOFF rc=%d\n",__func__, rc);
931 break;
932 default:
933 break;
934 }
935 break;
936 default:
937 break;
938 }
939 CDBG("%s:ch=%d\n",__func__, ch_type);
940 rc = mm_camera_send_ch_on_off_event(my_obj,ch_type,MM_CAMERA_CH_EVT_STREAMING_OFF);
941 return rc;
942 }
943
mm_camera_init_ch_stream_count(mm_camera_obj_t * my_obj)944 static void mm_camera_init_ch_stream_count(mm_camera_obj_t *my_obj)
945 {
946 int i;
947
948 for(i = 0; i < MM_CAMERA_CH_MAX; i++) {
949 if(i == MM_CAMERA_CH_SNAPSHOT) {
950 my_obj->ch_stream_count[i].stream_on_count_cfg = 2;
951 my_obj->ch_stream_count[i].stream_off_count_cfg = 2;
952 } else {
953 my_obj->ch_stream_count[i].stream_on_count_cfg = 1;
954 my_obj->ch_stream_count[i].stream_off_count_cfg = 1;
955 }
956 }
957 }
958
mm_camera_open(mm_camera_obj_t * my_obj,mm_camera_op_mode_type_t op_mode)959 int32_t mm_camera_open(mm_camera_obj_t *my_obj,
960 mm_camera_op_mode_type_t op_mode)
961 {
962 char dev_name[MM_CAMERA_DEV_NAME_LEN];
963 int32_t rc = MM_CAMERA_OK;
964 int8_t n_try=MM_CAMERA_DEV_OPEN_TRIES;
965 uint8_t sleep_msec=MM_CAMERA_DEV_OPEN_RETRY_SLEEP;
966 uint8_t i;
967
968 CDBG("%s: begin\n", __func__);
969
970 if(my_obj->op_mode != MM_CAMERA_OP_MODE_NOTUSED) {
971 CDBG("%s: not allowed in existing op mode %d\n",
972 __func__, my_obj->op_mode);
973 return -MM_CAMERA_E_INVALID_OPERATION;
974 }
975 if(op_mode >= MM_CAMERA_OP_MODE_MAX) {
976 CDBG("%s: invalid input %d\n",
977 __func__, op_mode);
978 return -MM_CAMERA_E_INVALID_INPUT;
979 }
980 snprintf(dev_name, sizeof(dev_name), "/dev/%s", mm_camera_util_get_dev_name(my_obj));
981 //rc = mm_camera_dev_open(&my_obj->ctrl_fd, dev_name);
982 CDBG("%s: mm_camera_dev_open rc = %d\n", __func__, rc);
983
984 do{
985 n_try--;
986 my_obj->ctrl_fd = open(dev_name,O_RDWR | O_NONBLOCK);
987 ALOGV("%s: ctrl_fd = %d", __func__, my_obj->ctrl_fd);
988 ALOGV("Errno:%d",errno);
989 if((my_obj->ctrl_fd > 0) || (errno != EIO) || (n_try <= 0 )) {
990 ALOGV("%s: opened, break out while loop", __func__);
991
992 break;
993 }
994 CDBG("%s:failed with I/O error retrying after %d milli-seconds",
995 __func__,sleep_msec);
996 usleep(sleep_msec*1000);
997 }while(n_try>0);
998
999 ALOGV("%s: after while loop", __func__);
1000 if (my_obj->ctrl_fd <= 0) {
1001 CDBG("%s: cannot open control fd of '%s' Errno = %d\n",
1002 __func__, mm_camera_util_get_dev_name(my_obj),errno);
1003 return -MM_CAMERA_E_GENERAL;
1004 }
1005 ALOGV("%s: 2\n", __func__);
1006
1007 /* open domain socket*/
1008 n_try=MM_CAMERA_DEV_OPEN_TRIES;
1009 do{
1010 n_try--;
1011 my_obj->ds_fd = mm_camera_socket_create(my_obj->my_id, MM_CAMERA_SOCK_TYPE_UDP); // TODO: UDP for now, change to TCP
1012 ALOGV("%s: ds_fd = %d", __func__, my_obj->ds_fd);
1013 ALOGV("Errno:%d",errno);
1014 if((my_obj->ds_fd > 0) || (n_try <= 0 )) {
1015 ALOGV("%s: opened, break out while loop", __func__);
1016 break;
1017 }
1018 CDBG("%s:failed with I/O error retrying after %d milli-seconds",
1019 __func__,sleep_msec);
1020 usleep(sleep_msec*1000);
1021 }while(n_try>0);
1022
1023 ALOGV("%s: after while loop for domain socket open", __func__);
1024 if (my_obj->ds_fd <= 0) {
1025 CDBG_ERROR("%s: cannot open domain socket fd of '%s' Errno = %d\n",
1026 __func__, mm_camera_util_get_dev_name(my_obj),errno);
1027 close(my_obj->ctrl_fd);
1028 my_obj->ctrl_fd = -1;
1029 return -MM_CAMERA_E_GENERAL;
1030 }
1031
1032 /* set ctrl_fd to be the mem_mapping fd */
1033 rc = mm_camera_util_s_ctrl(my_obj->ctrl_fd,
1034 MSM_V4L2_PID_MMAP_INST, 0);
1035 if (rc != MM_CAMERA_OK) {
1036 CDBG_ERROR("error: ioctl VIDIOC_S_CTRL MSM_V4L2_PID_MMAP_INST failed: %s\n",
1037 strerror(errno));
1038 close(my_obj->ctrl_fd);
1039 close(my_obj->ds_fd);
1040 my_obj->ctrl_fd = -1;
1041 my_obj->ds_fd = -1;
1042 return -MM_CAMERA_E_GENERAL;
1043 }
1044 if(op_mode != MM_CAMERA_OP_MODE_NOTUSED)
1045 rc = mm_camera_util_s_ctrl(my_obj->ctrl_fd,
1046 MSM_V4L2_PID_CAM_MODE, op_mode);
1047 if(!rc) {
1048 my_obj->op_mode = op_mode;
1049 my_obj->current_mode = CAMERA_MODE_2D; /* set geo mode to 2D by default */
1050 }
1051
1052 /* get camera capabilities */
1053 memset(&my_obj->properties, 0, sizeof(cam_prop_t));
1054 rc = mm_camera_send_native_ctrl_cmd(my_obj,
1055 CAMERA_GET_CAPABILITIES,
1056 sizeof(cam_prop_t),
1057 (void *)& my_obj->properties);
1058 if (rc != MM_CAMERA_OK) {
1059 CDBG_ERROR("%s: cannot get camera capabilities\n", __func__);
1060 close(my_obj->ctrl_fd);
1061 close(my_obj->ds_fd);
1062 my_obj->ctrl_fd = -1;
1063 my_obj->ds_fd = -1;
1064 return -MM_CAMERA_E_GENERAL;
1065 }
1066
1067 mm_camera_poll_threads_init(my_obj);
1068 mm_camera_init_ch_stream_count(my_obj);
1069 CDBG("%s : Launch Threads in Cam Open",__func__);
1070 for(i = 0; i < MM_CAMERA_CH_MAX; i++) {
1071 mm_camera_poll_thread_launch(my_obj,(mm_camera_channel_type_t)i);
1072 }
1073 CDBG("%s: '%s', ctrl_fd=%d,op_mode=%d,rc=%d\n",
1074 __func__, dev_name, my_obj->ctrl_fd, my_obj->op_mode, rc);
1075 return rc;
1076 }
1077
mm_camera_close(mm_camera_obj_t * my_obj)1078 int32_t mm_camera_close(mm_camera_obj_t *my_obj)
1079 {
1080 int i, rc = 0;
1081
1082 for(i = 0; i < MM_CAMERA_CH_MAX; i++){
1083 mm_camera_ch_fn(my_obj, (mm_camera_channel_type_t)i,
1084 MM_CAMERA_STATE_EVT_RELEASE, NULL);
1085 }
1086
1087 CDBG("%s : Close Threads in Cam Close",__func__);
1088 for(i = 0; i < MM_CAMERA_CH_MAX; i++) {
1089 mm_camera_poll_thread_release(my_obj,(mm_camera_channel_type_t)i);
1090 }
1091 mm_camera_poll_threads_deinit(my_obj);
1092 my_obj->op_mode = MM_CAMERA_OP_MODE_NOTUSED;
1093 if(my_obj->ctrl_fd > 0) {
1094 rc = close(my_obj->ctrl_fd);
1095 if(rc < 0) {
1096 /* this is a dead end. */
1097 CDBG("%s: !!!!FATAL ERROR!!!! ctrl_fd = %d, rc = %d",
1098 __func__, my_obj->ctrl_fd, rc);
1099 }
1100 my_obj->ctrl_fd = 0;
1101 }
1102 if(my_obj->ds_fd > 0) {
1103 mm_camera_socket_close(my_obj->ds_fd);
1104 my_obj->ds_fd = 0;
1105 }
1106 return MM_CAMERA_OK;
1107 }
1108
mm_camera_action(mm_camera_obj_t * my_obj,uint8_t start,mm_camera_ops_type_t opcode,void * parm)1109 int32_t mm_camera_action(mm_camera_obj_t *my_obj, uint8_t start,
1110 mm_camera_ops_type_t opcode, void *parm)
1111 {
1112 int32_t rc = - MM_CAMERA_E_INVALID_OPERATION;
1113
1114 if(start) rc = mm_camera_action_start(my_obj, opcode, parm);
1115 else rc = mm_camera_action_stop(my_obj, opcode, parm);
1116 CDBG("%s:start_flag=%d,opcode=%d,parm=%p,rc=%d\n",__func__,start,opcode,parm, rc);
1117 return rc;
1118 }
1119
mm_camera_ch_acquire(mm_camera_obj_t * my_obj,mm_camera_channel_type_t ch_type)1120 int32_t mm_camera_ch_acquire(mm_camera_obj_t *my_obj, mm_camera_channel_type_t ch_type)
1121 {
1122 return mm_camera_ch_fn(my_obj,ch_type, MM_CAMERA_STATE_EVT_ACQUIRE, 0);
1123 }
1124
mm_camera_ch_release(mm_camera_obj_t * my_obj,mm_camera_channel_type_t ch_type)1125 void mm_camera_ch_release(mm_camera_obj_t *my_obj, mm_camera_channel_type_t ch_type)
1126 {
1127 mm_camera_ch_fn(my_obj,ch_type, MM_CAMERA_STATE_EVT_RELEASE, 0);
1128 }
1129
mm_camera_sendmsg(mm_camera_obj_t * my_obj,void * msg,uint32_t buf_size,int sendfd)1130 int32_t mm_camera_sendmsg(mm_camera_obj_t *my_obj, void *msg, uint32_t buf_size, int sendfd)
1131 {
1132 return mm_camera_socket_sendmsg(my_obj->ds_fd, msg, buf_size, sendfd);
1133 }
1134