projects / GitHub / LineageOS / android_hardware_samsung_slsi_exynos5.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
hardware: samsung_slsi: libcamera2: Modify Debug Message
[GitHub/LineageOS/android_hardware_samsung_slsi_exynos5.git] / libcamera2 / ExynosCameraHWInterface2.cpp
CommitLineData
c15a6b00
JS		 1/*
2**
3** Copyright 2008, The Android Open Source Project
4** Copyright 2012, Samsung Electronics Co. LTD
5**
6** Licensed under the Apache License, Version 2.0 (the "License");
7** you may not use this file except in compliance with the License.
8** You may obtain a copy of the License at
9**
10** http://www.apache.org/licenses/LICENSE-2.0
11**
12** Unless required by applicable law or agreed to in writing, software
13** distributed under the License is distributed on an "AS IS" BASIS,
14** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15** See the License for the specific language governing permissions and
16** limitations under the License.
17*/
18
19/*!
20 * \file ExynosCameraHWInterface2.cpp
21 * \brief source file for Android Camera API 2.0 HAL
22 * \author Sungjoong Kang(sj3.kang@samsung.com)
13d8c7b4 23 * \date 2012/07/10
c15a6b00
JS		 24 *
25 * <b>Revision History: </b>
26 * - 2012/05/31 : Sungjoong Kang(sj3.kang@samsung.com) \n
27 * Initial Release
13d8c7b4
SK		 28 *
29 * - 2012/07/10 : Sungjoong Kang(sj3.kang@samsung.com) \n
30 * 2nd Release
31 *
c15a6b00
JS		 32 */
33
34//#define LOG_NDEBUG 0
9dd63e1f 35#define LOG_TAG "ExynosCameraHAL2"
c15a6b00
JS		 36#include <utils/Log.h>
37
38#include "ExynosCameraHWInterface2.h"
39#include "exynos_format.h"
40
c15a6b00
JS		 41namespace android {
42
9dd63e1f
SK		 43void m_savePostView(const char *fname, uint8_t *buf, uint32_t size)
44{
45 int nw;
46 int cnt = 0;
47 uint32_t written = 0;
48
ad37861e 49 ALOGV("opening file [%s], address[%x], size(%d)", fname, (unsigned int)buf, size);
9dd63e1f
SK		 50 int fd = open(fname, O_RDWR | O_CREAT, 0644);
51 if (fd < 0) {
52 ALOGE("failed to create file [%s]: %s", fname, strerror(errno));
53 return;
54 }
55
ad37861e 56 ALOGV("writing %d bytes to file [%s]", size, fname);
9dd63e1f
SK		 57 while (written < size) {
58 nw = ::write(fd, buf + written, size - written);
59 if (nw < 0) {
60 ALOGE("failed to write to file %d [%s]: %s",written,fname, strerror(errno));
61 break;
62 }
63 written += nw;
64 cnt++;
65 }
ad37861e 66 ALOGV("done writing %d bytes to file [%s] in %d passes",size, fname, cnt);
9dd63e1f
SK		 67 ::close(fd);
68}
69
c15a6b00
JS		 70int get_pixel_depth(uint32_t fmt)
71{
72 int depth = 0;
73
74 switch (fmt) {
75 case V4L2_PIX_FMT_JPEG:
76 depth = 8;
77 break;
78
79 case V4L2_PIX_FMT_NV12:
80 case V4L2_PIX_FMT_NV21:
81 case V4L2_PIX_FMT_YUV420:
82 case V4L2_PIX_FMT_YVU420M:
83 case V4L2_PIX_FMT_NV12M:
84 case V4L2_PIX_FMT_NV12MT:
85 depth = 12;
86 break;
87
88 case V4L2_PIX_FMT_RGB565:
89 case V4L2_PIX_FMT_YUYV:
90 case V4L2_PIX_FMT_YVYU:
91 case V4L2_PIX_FMT_UYVY:
92 case V4L2_PIX_FMT_VYUY:
93 case V4L2_PIX_FMT_NV16:
94 case V4L2_PIX_FMT_NV61:
95 case V4L2_PIX_FMT_YUV422P:
96 case V4L2_PIX_FMT_SBGGR10:
97 case V4L2_PIX_FMT_SBGGR12:
98 case V4L2_PIX_FMT_SBGGR16:
99 depth = 16;
100 break;
101
102 case V4L2_PIX_FMT_RGB32:
103 depth = 32;
104 break;
105 default:
106 ALOGE("Get depth failed(format : %d)", fmt);
107 break;
108 }
109
110 return depth;
13d8c7b4 111}
c15a6b00
JS		 112
113int cam_int_s_fmt(node_info_t *node)
114{
115 struct v4l2_format v4l2_fmt;
116 unsigned int framesize;
117 int ret;
118
119 memset(&v4l2_fmt, 0, sizeof(struct v4l2_format));
120
121 v4l2_fmt.type = node->type;
122 framesize = (node->width * node->height * get_pixel_depth(node->format)) / 8;
123
124 if (node->planes >= 1) {
125 v4l2_fmt.fmt.pix_mp.width = node->width;
126 v4l2_fmt.fmt.pix_mp.height = node->height;
127 v4l2_fmt.fmt.pix_mp.pixelformat = node->format;
128 v4l2_fmt.fmt.pix_mp.field = V4L2_FIELD_ANY;
129 } else {
13d8c7b4 130 ALOGE("%s:S_FMT, Out of bound : Number of element plane",__FUNCTION__);
c15a6b00
JS		 131 }
132
133 /* Set up for capture */
134 ret = exynos_v4l2_s_fmt(node->fd, &v4l2_fmt);
135
136 if (ret < 0)
13d8c7b4 137 ALOGE("%s: exynos_v4l2_s_fmt fail (%d)",__FUNCTION__, ret);
c15a6b00 138
be494d19 139
c15a6b00
JS		 140 return ret;
141}
142
143int cam_int_reqbufs(node_info_t *node)
144{
145 struct v4l2_requestbuffers req;
146 int ret;
147
148 req.count = node->buffers;
149 req.type = node->type;
150 req.memory = node->memory;
151
152 ret = exynos_v4l2_reqbufs(node->fd, &req);
153
154 if (ret < 0)
13d8c7b4 155 ALOGE("%s: VIDIOC_REQBUFS (fd:%d) failed (%d)",__FUNCTION__,node->fd, ret);
c15a6b00
JS		 156
157 return req.count;
158}
159
160int cam_int_qbuf(node_info_t *node, int index)
161{
162 struct v4l2_buffer v4l2_buf;
163 struct v4l2_plane planes[VIDEO_MAX_PLANES];
164 int i;
165 int ret = 0;
166
167 v4l2_buf.m.planes = planes;
168 v4l2_buf.type = node->type;
169 v4l2_buf.memory = node->memory;
170 v4l2_buf.index = index;
171 v4l2_buf.length = node->planes;
172
173 for(i = 0; i < node->planes; i++){
13d8c7b4
SK		 174 v4l2_buf.m.planes[i].m.fd = (int)(node->buffer[index].fd.extFd[i]);
175 v4l2_buf.m.planes[i].length = (unsigned long)(node->buffer[index].size.extS[i]);
c15a6b00
JS		 176 }
177
178 ret = exynos_v4l2_qbuf(node->fd, &v4l2_buf);
179
180 if (ret < 0)
13d8c7b4 181 ALOGE("%s: cam_int_qbuf failed (index:%d)(ret:%d)",__FUNCTION__, index, ret);
c15a6b00
JS		 182
183 return ret;
184}
185
186int cam_int_streamon(node_info_t *node)
187{
188 enum v4l2_buf_type type = node->type;
189 int ret;
190
be494d19 191
c15a6b00
JS		 192 ret = exynos_v4l2_streamon(node->fd, type);
193
194 if (ret < 0)
ad37861e 195 ALOGE("%s: VIDIOC_STREAMON failed [%d] (%d)",__FUNCTION__, node->fd,ret);
c15a6b00
JS		 196
197 ALOGV("On streaming I/O... ... fd(%d)", node->fd);
198
199 return ret;
200}
201
13d8c7b4
SK		 202int cam_int_streamoff(node_info_t *node)
203{
ad37861e
SK		 204 enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
205 int ret;
13d8c7b4 206
be494d19 207
ad37861e
SK		 208 ALOGV("Off streaming I/O... fd(%d)", node->fd);
209 ret = exynos_v4l2_streamoff(node->fd, type);
13d8c7b4
SK		 210
211 if (ret < 0)
212 ALOGE("%s: VIDIOC_STREAMOFF failed (%d)",__FUNCTION__, ret);
213
ad37861e 214 return ret;
13d8c7b4
SK		 215}
216
9dd63e1f
SK		 217int isp_int_streamoff(node_info_t *node)
218{
ad37861e
SK		 219 enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
220 int ret;
9dd63e1f 221
ad37861e
SK		 222 ALOGV("Off streaming I/O... fd(%d)", node->fd);
223 ret = exynos_v4l2_streamoff(node->fd, type);
9dd63e1f
SK		 224
225 if (ret < 0)
226 ALOGE("%s: VIDIOC_STREAMOFF failed (%d)",__FUNCTION__, ret);
227
ad37861e 228 return ret;
9dd63e1f
SK		 229}
230
c15a6b00
JS		 231int cam_int_dqbuf(node_info_t *node)
232{
233 struct v4l2_buffer v4l2_buf;
234 struct v4l2_plane planes[VIDEO_MAX_PLANES];
235 int ret;
236
237 v4l2_buf.type = node->type;
238 v4l2_buf.memory = node->memory;
239 v4l2_buf.m.planes = planes;
240 v4l2_buf.length = node->planes;
241
242 ret = exynos_v4l2_dqbuf(node->fd, &v4l2_buf);
243 if (ret < 0)
13d8c7b4 244 ALOGE("%s: VIDIOC_DQBUF failed (%d)",__FUNCTION__, ret);
c15a6b00
JS		 245
246 return v4l2_buf.index;
247}
248
feb7df4c
SK		 249int cam_int_dqbuf(node_info_t *node, int num_plane)
250{
251 struct v4l2_buffer v4l2_buf;
252 struct v4l2_plane planes[VIDEO_MAX_PLANES];
253 int ret;
254
255 v4l2_buf.type = node->type;
256 v4l2_buf.memory = node->memory;
257 v4l2_buf.m.planes = planes;
258 v4l2_buf.length = num_plane;
259
260 ret = exynos_v4l2_dqbuf(node->fd, &v4l2_buf);
261 if (ret < 0)
262 ALOGE("%s: VIDIOC_DQBUF failed (%d)",__FUNCTION__, ret);
263
264 return v4l2_buf.index;
265}
266
c15a6b00
JS		 267int cam_int_s_input(node_info_t *node, int index)
268{
269 int ret;
13d8c7b4 270
c15a6b00
JS		 271 ret = exynos_v4l2_s_input(node->fd, index);
272 if (ret < 0)
13d8c7b4 273 ALOGE("%s: VIDIOC_S_INPUT failed (%d)",__FUNCTION__, ret);
c15a6b00
JS		 274
275 return ret;
276}
277
278
279gralloc_module_t const* ExynosCameraHWInterface2::m_grallocHal;
280
281RequestManager::RequestManager(SignalDrivenThread* main_thread):
2bdec060
SK		 282 m_lastAeMode(0),
283 m_lastAaMode(0),
284 m_lastAwbMode(0),
5c88d1f2
C		 285#ifdef VDIS_ENABLE
286 m_vdisBubbleEn(false),
287#endif
2bdec060 288 m_lastAeComp(0),
ad37861e 289 m_frameIndex(-1)
c15a6b00
JS		 290{
291 m_metadataConverter = new MetadataConverter;
292 m_mainThread = main_thread;
2adfa429 293 ResetEntry();
ad37861e 294 m_sensorPipelineSkipCnt = 0;
c15a6b00
JS		 295 return;
296}
297
298RequestManager::~RequestManager()
299{
15fd8231
SK		 300 ALOGV("%s", __FUNCTION__);
301 if (m_metadataConverter != NULL) {
302 delete m_metadataConverter;
303 m_metadataConverter = NULL;
304 }
305
52f54308 306 releaseSensorQ();
c15a6b00
JS		 307 return;
308}
309
2adfa429
JS		 310void RequestManager::ResetEntry()
311{
312 Mutex::Autolock lock(m_requestMutex);
313 for (int i=0 ; i<NUM_MAX_REQUEST_MGR_ENTRY; i++) {
314 memset(&(entries[i]), 0x00, sizeof(request_manager_entry_t));
315 entries[i].internal_shot.shot.ctl.request.frameCount = -1;
316 }
317 m_numOfEntries = 0;
318 m_entryInsertionIndex = -1;
319 m_entryProcessingIndex = -1;
320 m_entryFrameOutputIndex = -1;
321}
322
c15a6b00
JS		 323int RequestManager::GetNumEntries()
324{
325 return m_numOfEntries;
326}
327
9dd63e1f
SK		 328void RequestManager::SetDefaultParameters(int cropX)
329{
330 m_cropX = cropX;
331}
332
c15a6b00
JS		 333bool RequestManager::IsRequestQueueFull()
334{
335 Mutex::Autolock lock(m_requestMutex);
336 if (m_numOfEntries>=NUM_MAX_REQUEST_MGR_ENTRY)
337 return true;
338 else
339 return false;
340}
341
342void RequestManager::RegisterRequest(camera_metadata_t * new_request)
343{
13d8c7b4
SK		 344 ALOGV("DEBUG(%s):", __FUNCTION__);
345
c15a6b00 346 Mutex::Autolock lock(m_requestMutex);
13d8c7b4 347
c15a6b00 348 request_manager_entry * newEntry = NULL;
9dd63e1f 349 int newInsertionIndex = GetNextIndex(m_entryInsertionIndex);
13d8c7b4
SK		 350 ALOGV("DEBUG(%s): got lock, new insertIndex(%d), cnt before reg(%d)", __FUNCTION__,newInsertionIndex,m_numOfEntries );
351
c15a6b00 352
c15a6b00
JS		 353 newEntry = &(entries[newInsertionIndex]);
354
355 if (newEntry->status!=EMPTY) {
13d8c7b4
SK		 356 ALOGV("DEBUG(%s): Circular buffer abnormal ", __FUNCTION__);
357 return;
c15a6b00
JS		 358 }
359 newEntry->status = REGISTERED;
360 newEntry->original_request = new_request;
ad37861e 361 memset(&(newEntry->internal_shot), 0, sizeof(struct camera2_shot_ext));
13d8c7b4 362 m_metadataConverter->ToInternalShot(new_request, &(newEntry->internal_shot));
b56dcc00 363 newEntry->output_stream_count = newEntry->internal_shot.shot.ctl.request.outputStreams[15];
c15a6b00
JS		 364
365 m_numOfEntries++;
366 m_entryInsertionIndex = newInsertionIndex;
367
13d8c7b4 368
c15a6b00 369 ALOGV("## RegisterReq DONE num(%d), insert(%d), processing(%d), frame(%d), (frameCnt(%d))",
be494d19 370 m_numOfEntries,m_entryInsertionIndex,m_entryProcessingIndex, m_entryFrameOutputIndex, newEntry->internal_shot.shot.ctl.request.frameCount);
c15a6b00
JS		 371}
372
373void RequestManager::DeregisterRequest(camera_metadata_t ** deregistered_request)
374{
13d8c7b4 375 ALOGV("DEBUG(%s):", __FUNCTION__);
ad37861e
SK		 376 int frame_index;
377 request_manager_entry * currentEntry;
c15a6b00 378
ad37861e 379 Mutex::Autolock lock(m_requestMutex);
13d8c7b4 380
ad37861e
SK		 381 frame_index = GetFrameIndex();
382 currentEntry = &(entries[frame_index]);
2adfa429 383 if (currentEntry->status != METADONE) {
5c88d1f2
C		 384 CAM_LOGD("DBG(%s): Circular buffer abnormal. processing(%d), frame(%d), status(%d) ", __FUNCTION__,
385 m_entryProcessingIndex, frame_index,(int)(currentEntry->status));
13d8c7b4 386 return;
c15a6b00 387 }
13d8c7b4
SK		 388 if (deregistered_request) *deregistered_request = currentEntry->original_request;
389
c15a6b00
JS		 390 currentEntry->status = EMPTY;
391 currentEntry->original_request = NULL;
be494d19
SK		 392 memset(&(currentEntry->internal_shot), 0, sizeof(struct camera2_shot_ext));
393 currentEntry->internal_shot.shot.ctl.request.frameCount = -1;
c15a6b00
JS		 394 currentEntry->output_stream_count = 0;
395 m_numOfEntries--;
396 ALOGV("## DeRegistReq DONE num(%d), insert(%d), processing(%d), frame(%d)",
397 m_numOfEntries,m_entryInsertionIndex,m_entryProcessingIndex, m_entryFrameOutputIndex);
13d8c7b4 398
c15a6b00 399 return;
c15a6b00
JS		 400}
401
13d8c7b4 402bool RequestManager::PrepareFrame(size_t* num_entries, size_t* frame_size,
0f26b20f 403 camera_metadata_t ** prepared_frame, int afState)
c15a6b00 404{
13d8c7b4 405 ALOGV("DEBUG(%s):", __FUNCTION__);
c15a6b00
JS		 406 Mutex::Autolock lock(m_requestMutex);
407 status_t res = NO_ERROR;
ad37861e 408 int tempFrameOutputIndex = GetFrameIndex();
13d8c7b4
SK		 409 request_manager_entry * currentEntry = &(entries[tempFrameOutputIndex]);
410 ALOGV("DEBUG(%s): processing(%d), frameOut(%d), insert(%d) recentlycompleted(%d)", __FUNCTION__,
411 m_entryProcessingIndex, m_entryFrameOutputIndex, m_entryInsertionIndex, m_completedIndex);
412
2adfa429 413 if (currentEntry->status != METADONE) {
ad37861e 414 ALOGV("DBG(%s): Circular buffer abnormal status(%d)", __FUNCTION__, (int)(currentEntry->status));
13d8c7b4
SK		 415
416 return false;
417 }
418 m_entryFrameOutputIndex = tempFrameOutputIndex;
fd2d78a2 419 m_tempFrameMetadata = place_camera_metadata(m_tempFrameMetadataBuf, 2000, 20, 500); //estimated
0f26b20f 420 add_camera_metadata_entry(m_tempFrameMetadata, ANDROID_CONTROL_AF_STATE, &afState, 1);
13d8c7b4 421 res = m_metadataConverter->ToDynamicMetadata(&(currentEntry->internal_shot),
c15a6b00
JS		 422 m_tempFrameMetadata);
423 if (res!=NO_ERROR) {
13d8c7b4
SK		 424 ALOGE("ERROR(%s): ToDynamicMetadata (%d) ", __FUNCTION__, res);
425 return false;
c15a6b00
JS		 426 }
427 *num_entries = get_camera_metadata_entry_count(m_tempFrameMetadata);
428 *frame_size = get_camera_metadata_size(m_tempFrameMetadata);
429 *prepared_frame = m_tempFrameMetadata;
5506cebf
SK		 430 ALOGV("## PrepareFrame DONE: frameOut(%d) frameCnt-req(%d) timestamp(%lld)", m_entryFrameOutputIndex,
431 currentEntry->internal_shot.shot.ctl.request.frameCount, currentEntry->internal_shot.shot.dm.sensor.timeStamp);
9dd63e1f 432 // Dump();
13d8c7b4 433 return true;
c15a6b00
JS		 434}
435
0f26b20f 436int RequestManager::MarkProcessingRequest(ExynosBuffer* buf, int *afMode)
c15a6b00 437{
13d8c7b4 438 struct camera2_shot_ext * shot_ext;
b56dcc00 439 struct camera2_shot_ext * request_shot;
13d8c7b4 440 int targetStreamIndex = 0;
ad37861e 441 request_manager_entry * newEntry = NULL;
0f26b20f 442 static int count = 0;
13d8c7b4 443
52f54308 444 Mutex::Autolock lock(m_requestMutex);
13d8c7b4 445 if (m_numOfEntries == 0) {
4aa4d739 446 CAM_LOGD("DEBUG(%s): Request Manager Empty ", __FUNCTION__);
13d8c7b4
SK		 447 return -1;
448 }
449
450 if ((m_entryProcessingIndex == m_entryInsertionIndex)
be494d19 451 && (entries[m_entryProcessingIndex].status == REQUESTED || entries[m_entryProcessingIndex].status == CAPTURED)) {
da7ca692 452 ALOGV("## MarkProcReq skipping(request underrun) - num(%d), insert(%d), processing(%d), frame(%d)",
13d8c7b4
SK		 453 m_numOfEntries,m_entryInsertionIndex,m_entryProcessingIndex, m_entryFrameOutputIndex);
454 return -1;
455 }
c15a6b00 456
9dd63e1f 457 int newProcessingIndex = GetNextIndex(m_entryProcessingIndex);
ad37861e 458 ALOGV("DEBUG(%s): index(%d)", __FUNCTION__, newProcessingIndex);
c15a6b00 459
c15a6b00 460 newEntry = &(entries[newProcessingIndex]);
ad37861e 461 request_shot = &(newEntry->internal_shot);
0f26b20f 462 *afMode = (int)(newEntry->internal_shot.shot.ctl.aa.afMode);
be494d19 463 if (newEntry->status != REGISTERED) {
5c88d1f2
C		 464 CAM_LOGD("DEBUG(%s)(%d): Circular buffer abnormal, numOfEntries(%d), status(%d)", __FUNCTION__, newProcessingIndex, m_numOfEntries, newEntry->status);
465 for (int i = 0; i < NUM_MAX_REQUEST_MGR_ENTRY; i++) {
466 CAM_LOGD("DBG: entrie[%d].stream output cnt = %d, framecnt(%d)", i, entries[i].output_stream_count, entries[i].internal_shot.shot.ctl.request.frameCount);
467 }
13d8c7b4 468 return -1;
c15a6b00 469 }
ad37861e 470
be494d19 471 newEntry->status = REQUESTED;
c15a6b00 472
ad37861e 473 shot_ext = (struct camera2_shot_ext *)buf->virt.extP[1];
13d8c7b4 474
ad37861e
SK		 475 memset(shot_ext, 0x00, sizeof(struct camera2_shot_ext));
476 shot_ext->shot.ctl.request.frameCount = request_shot->shot.ctl.request.frameCount;
13d8c7b4 477 shot_ext->request_sensor = 1;
9dd63e1f
SK		 478 shot_ext->dis_bypass = 1;
479 shot_ext->dnr_bypass = 1;
ad37861e
SK		 480 shot_ext->fd_bypass = 1;
481 shot_ext->setfile = 0;
482
5506cebf
SK		 483 targetStreamIndex = newEntry->internal_shot.shot.ctl.request.outputStreams[0];
484 shot_ext->shot.ctl.request.outputStreams[0] = targetStreamIndex;
485 if (targetStreamIndex & MASK_OUTPUT_SCP)
486 shot_ext->request_scp = 1;
13d8c7b4 487
5506cebf
SK		 488 if (targetStreamIndex & MASK_OUTPUT_SCC)
489 shot_ext->request_scc = 1;
490
491 if (shot_ext->shot.ctl.stats.faceDetectMode != FACEDETECT_MODE_OFF)
492 shot_ext->fd_bypass = 0;
13d8c7b4 493
0f26b20f
SK		 494 if (count == 0){
495 shot_ext->shot.ctl.aa.mode = AA_CONTROL_AUTO;
496 } else
497 shot_ext->shot.ctl.aa.mode = AA_CONTROL_NONE;
498
499 count++;
ad37861e
SK		 500 shot_ext->shot.ctl.request.metadataMode = METADATA_MODE_FULL;
501 shot_ext->shot.ctl.stats.faceDetectMode = FACEDETECT_MODE_FULL;
502 shot_ext->shot.magicNumber = 0x23456789;
503 shot_ext->shot.ctl.sensor.exposureTime = 0;
504 shot_ext->shot.ctl.sensor.frameDuration = 33*1000*1000;
505 shot_ext->shot.ctl.sensor.sensitivity = 0;
506
e4657e32
SK		 507
508 shot_ext->shot.ctl.scaler.cropRegion[0] = newEntry->internal_shot.shot.ctl.scaler.cropRegion[0];
509 shot_ext->shot.ctl.scaler.cropRegion[1] = newEntry->internal_shot.shot.ctl.scaler.cropRegion[1];
510 shot_ext->shot.ctl.scaler.cropRegion[2] = newEntry->internal_shot.shot.ctl.scaler.cropRegion[2];
13d8c7b4 511
ad37861e
SK		 512 m_entryProcessingIndex = newProcessingIndex;
513 return newProcessingIndex;
c15a6b00
JS		 514}
515
2adfa429 516void RequestManager::NotifyStreamOutput(int frameCnt)
c15a6b00 517{
9dd63e1f
SK		 518 int index;
519
2adfa429
JS		 520 Mutex::Autolock lock(m_requestMutex);
521 ALOGV("DEBUG(%s): frameCnt(%d)", __FUNCTION__, frameCnt);
9dd63e1f
SK		 522
523 index = FindEntryIndexByFrameCnt(frameCnt);
524 if (index == -1) {
525 ALOGE("ERR(%s): Cannot find entry for frameCnt(%d)", __FUNCTION__, frameCnt);
526 return;
527 }
2adfa429 528 ALOGV("DEBUG(%s): frameCnt(%d), last cnt (%d)", __FUNCTION__, frameCnt, entries[index].output_stream_count);
9dd63e1f 529
be494d19
SK		 530 entries[index].output_stream_count--; //TODO : match stream id also
531 CheckCompleted(index);
13d8c7b4
SK		 532}
533
534void RequestManager::CheckCompleted(int index)
535{
2adfa429
JS		 536 if((entries[index].status == METADONE) && (entries[index].output_stream_count <= 0)){
537 ALOGV("send SIGNAL_MAIN_STREAM_OUTPUT_DONE(index:%d)(frameCnt:%d)",
538 index, entries[index].internal_shot.shot.ctl.request.frameCount );
539 SetFrameIndex(index);
540 m_mainThread->SetSignal(SIGNAL_MAIN_STREAM_OUTPUT_DONE);
541 }
c15a6b00 542}
9dd63e1f 543
ad37861e
SK		 544void RequestManager::SetFrameIndex(int index)
545{
ad37861e
SK		 546 m_frameIndex = index;
547}
548
549int RequestManager::GetFrameIndex()
550{
551 return m_frameIndex;
552}
553
52f54308
SK		 554void RequestManager::pushSensorQ(int index)
555{
556 Mutex::Autolock lock(m_requestMutex);
557 m_sensorQ.push_back(index);
558}
559
560int RequestManager::popSensorQ()
561{
562 List<int>::iterator sensor_token;
563 int index;
564
565 Mutex::Autolock lock(m_requestMutex);
566
567 if(m_sensorQ.size() == 0)
568 return -1;
569
570 sensor_token = m_sensorQ.begin()++;
571 index = *sensor_token;
572 m_sensorQ.erase(sensor_token);
573
574 return (index);
575}
576
577void RequestManager::releaseSensorQ()
578{
579 List<int>::iterator r;
580
581 Mutex::Autolock lock(m_requestMutex);
582 ALOGV("(%d)m_sensorQ.size : %d", __FUNCTION__, m_sensorQ.size());
583
584 while(m_sensorQ.size() > 0){
585 r = m_sensorQ.begin()++;
586 m_sensorQ.erase(r);
587 }
588 return;
589}
590
ad37861e 591void RequestManager::ApplyDynamicMetadata(struct camera2_shot_ext *shot_ext)
13d8c7b4 592{
9dd63e1f 593 int index;
b56dcc00
SK		 594 struct camera2_shot_ext * request_shot;
595 nsecs_t timeStamp;
ad37861e 596 int i;
13d8c7b4 597
52f54308 598 Mutex::Autolock lock(m_requestMutex);
ad37861e 599 ALOGV("DEBUG(%s): frameCnt(%d)", __FUNCTION__, shot_ext->shot.ctl.request.frameCount);
9dd63e1f 600
ad37861e
SK		 601 for (i = 0 ; i < NUM_MAX_REQUEST_MGR_ENTRY ; i++) {
602 if((entries[i].internal_shot.shot.ctl.request.frameCount == shot_ext->shot.ctl.request.frameCount)
2adfa429
JS		 603 && (entries[i].status == CAPTURED)){
604 entries[i].status =METADONE;
ad37861e 605 break;
2adfa429 606 }
ad37861e
SK		 607 }
608
609 if (i == NUM_MAX_REQUEST_MGR_ENTRY){
610 ALOGE("[%s] no entry found(framecount:%d)", __FUNCTION__, shot_ext->shot.ctl.request.frameCount);
9dd63e1f 611 return;
13d8c7b4 612 }
9dd63e1f 613
ad37861e 614 request_manager_entry * newEntry = &(entries[i]);
b56dcc00 615 request_shot = &(newEntry->internal_shot);
9dd63e1f 616
b56dcc00 617 timeStamp = request_shot->shot.dm.sensor.timeStamp;
ad37861e 618 memcpy(&(request_shot->shot.dm), &(shot_ext->shot.dm), sizeof(struct camera2_dm));
b56dcc00 619 request_shot->shot.dm.sensor.timeStamp = timeStamp;
5506cebf 620 m_lastTimeStamp = timeStamp;
ad37861e 621 CheckCompleted(i);
13d8c7b4
SK		 622}
623
53f62ad9 624void RequestManager::UpdateIspParameters(struct camera2_shot_ext *shot_ext, int frameCnt, ctl_request_info_t *ctl_info)
13d8c7b4 625{
9dd63e1f 626 int index, targetStreamIndex;
b56dcc00 627 struct camera2_shot_ext * request_shot;
9dd63e1f
SK		 628
629 ALOGV("DEBUG(%s): updating info with frameCnt(%d)", __FUNCTION__, frameCnt);
630 if (frameCnt < 0)
13d8c7b4 631 return;
9dd63e1f
SK		 632
633 index = FindEntryIndexByFrameCnt(frameCnt);
634 if (index == -1) {
635 ALOGE("ERR(%s): Cannot find entry for frameCnt(%d)", __FUNCTION__, frameCnt);
636 return;
637 }
638
13d8c7b4 639 request_manager_entry * newEntry = &(entries[index]);
ad37861e 640 request_shot = &(newEntry->internal_shot);
2bdec060 641 memcpy(&(shot_ext->shot.ctl), &(request_shot->shot.ctl), sizeof(struct camera2_ctl));
2adfa429 642 shot_ext->shot.ctl.request.frameCount = frameCnt;
13d8c7b4 643 shot_ext->request_sensor = 1;
ad37861e
SK		 644 shot_ext->dis_bypass = 1;
645 shot_ext->dnr_bypass = 1;
646 shot_ext->fd_bypass = 1;
647 shot_ext->setfile = 0;
648
13d8c7b4
SK		 649 shot_ext->request_scc = 0;
650 shot_ext->request_scp = 0;
ad37861e 651
5506cebf
SK		 652 shot_ext->isReprocessing = request_shot->isReprocessing;
653 shot_ext->reprocessInput = request_shot->reprocessInput;
9dd63e1f 654 shot_ext->shot.ctl.request.outputStreams[0] = 0;
9dd63e1f 655
e4657e32
SK		 656 shot_ext->shot.ctl.scaler.cropRegion[0] = request_shot->shot.ctl.scaler.cropRegion[0];
657 shot_ext->shot.ctl.scaler.cropRegion[1] = request_shot->shot.ctl.scaler.cropRegion[1];
658 shot_ext->shot.ctl.scaler.cropRegion[2] = request_shot->shot.ctl.scaler.cropRegion[2];
659
53f62ad9
YJ		 660 // mapping flash UI mode from aeMode
661 if (request_shot->shot.ctl.aa.aeMode >= AA_AEMODE_ON) {
662 ctl_info->flash.i_flashMode = request_shot->shot.ctl.aa.aeMode;
663 request_shot->shot.ctl.aa.aeMode = AA_AEMODE_ON;
664 }
665 // mapping awb UI mode form awbMode
666 ctl_info->awb.i_awbMode = request_shot->shot.ctl.aa.awbMode;
667
668 // Apply ae/awb lock or unlock
e117f756
YJ		 669 if (request_shot->ae_lock == AEMODE_LOCK_ON)
670 request_shot->shot.ctl.aa.aeMode = AA_AEMODE_LOCKED;
671 if (request_shot->awb_lock == AWBMODE_LOCK_ON)
672 request_shot->shot.ctl.aa.awbMode = AA_AWBMODE_LOCKED;
673
674 // This is for pre-capture metering
675 if (ctl_info->ae.m_aeCnt >= IS_COMMAND_EXECUTION) {
676 if (ctl_info->ae.m_aeCnt == IS_COMMAND_CLEAR) {
677 ALOGV("(%s) [Capture] m_aeCnt : CLEAR -> NONE", __FUNCTION__);
678 ctl_info->ae.m_aeCnt = IS_COMMAND_NONE;
679 } else {
680 ctl_info->ae.m_aeCnt = IS_COMMAND_CLEAR;
681 ALOGV("(%s) [Capture] m_aeCnt : EXECUTION -> CLEAR", __FUNCTION__);
682 }
53f62ad9 683 }
e117f756
YJ		 684 if (ctl_info->awb.m_awbCnt >= IS_COMMAND_EXECUTION) {
685 if (ctl_info->awb.m_awbCnt == IS_COMMAND_CLEAR)
686 ctl_info->awb.m_awbCnt = IS_COMMAND_NONE;
687 else
688 ctl_info->awb.m_awbCnt = IS_COMMAND_CLEAR;
53f62ad9
YJ		 689 }
690
2bdec060
SK		 691 if (m_lastAaMode == request_shot->shot.ctl.aa.mode) {
692 shot_ext->shot.ctl.aa.mode = (enum aa_mode)(0);
693 }
694 else {
695 shot_ext->shot.ctl.aa.mode = request_shot->shot.ctl.aa.mode;
696 m_lastAaMode = (int)(shot_ext->shot.ctl.aa.mode);
697 }
698 if (m_lastAeMode == request_shot->shot.ctl.aa.aeMode) {
699 shot_ext->shot.ctl.aa.aeMode = (enum aa_aemode)(0);
700 }
701 else {
702 shot_ext->shot.ctl.aa.aeMode = request_shot->shot.ctl.aa.aeMode;
703 m_lastAeMode = (int)(shot_ext->shot.ctl.aa.aeMode);
704 }
705 if (m_lastAwbMode == request_shot->shot.ctl.aa.awbMode) {
706 shot_ext->shot.ctl.aa.awbMode = (enum aa_awbmode)(0);
707 }
708 else {
709 shot_ext->shot.ctl.aa.awbMode = request_shot->shot.ctl.aa.awbMode;
710 m_lastAwbMode = (int)(shot_ext->shot.ctl.aa.awbMode);
711 }
712 if (m_lastAeComp == request_shot->shot.ctl.aa.aeExpCompensation) {
713 shot_ext->shot.ctl.aa.aeExpCompensation = 0;
714 }
715 else {
716 shot_ext->shot.ctl.aa.aeExpCompensation = request_shot->shot.ctl.aa.aeExpCompensation;
717 m_lastAeComp = (int)(shot_ext->shot.ctl.aa.aeExpCompensation);
718 }
ef6f83ca 719
5c88d1f2
C		 720#ifdef VDIS_ENABLE
721 if (request_shot->shot.ctl.aa.videoStabilizationMode) {
722 m_vdisBubbleEn = true;
723 shot_ext->dis_bypass = 0;
724 } else {
725 m_vdisBubbleEn = false;
726 shot_ext->dis_bypass = 1;
727 }
728#endif
729
ef6f83ca
SK		 730 shot_ext->shot.ctl.aa.afTrigger = 0;
731
5506cebf
SK		 732 targetStreamIndex = newEntry->internal_shot.shot.ctl.request.outputStreams[0];
733 shot_ext->shot.ctl.request.outputStreams[0] = targetStreamIndex;
734 if (targetStreamIndex & MASK_OUTPUT_SCP)
735 shot_ext->request_scp = 1;
13d8c7b4 736
5506cebf
SK		 737 if (targetStreamIndex & MASK_OUTPUT_SCC)
738 shot_ext->request_scc = 1;
739
740 if (shot_ext->shot.ctl.stats.faceDetectMode != FACEDETECT_MODE_OFF)
741 shot_ext->fd_bypass = 0;
742
743 if (targetStreamIndex & STREAM_MASK_RECORD) {
744 shot_ext->shot.ctl.aa.aeTargetFpsRange[0] = 30;
745 shot_ext->shot.ctl.aa.aeTargetFpsRange[1] = 30;
13d8c7b4 746 }
5506cebf
SK		 747
748 ALOGV("(%s): applied aa(%d) aemode(%d) expComp(%d), awb(%d) afmode(%d), ", __FUNCTION__,
749 (int)(shot_ext->shot.ctl.aa.mode), (int)(shot_ext->shot.ctl.aa.aeMode),
750 (int)(shot_ext->shot.ctl.aa.aeExpCompensation), (int)(shot_ext->shot.ctl.aa.awbMode),
751 (int)(shot_ext->shot.ctl.aa.afMode));
13d8c7b4
SK		 752}
753
5c88d1f2
C		 754#ifdef VDIS_ENABLE
755bool RequestManager::IsVdisEnable(void)
756{
757 return m_vdisBubbleEn;
758}
759#endif
760
9dd63e1f
SK		 761int RequestManager::FindEntryIndexByFrameCnt(int frameCnt)
762{
763 for (int i = 0 ; i < NUM_MAX_REQUEST_MGR_ENTRY ; i++) {
be494d19 764 if (entries[i].internal_shot.shot.ctl.request.frameCount == frameCnt)
9dd63e1f
SK		 765 return i;
766 }
767 return -1;
768}
769
770void RequestManager::RegisterTimestamp(int frameCnt, nsecs_t * frameTime)
13d8c7b4 771{
9dd63e1f
SK		 772 int index = FindEntryIndexByFrameCnt(frameCnt);
773 if (index == -1) {
774 ALOGE("ERR(%s): Cannot find entry for frameCnt(%d)", __FUNCTION__, frameCnt);
775 return;
776 }
777
13d8c7b4 778 request_manager_entry * currentEntry = &(entries[index]);
be494d19 779 currentEntry->internal_shot.shot.dm.sensor.timeStamp = *((uint64_t*)frameTime);
9dd63e1f 780 ALOGV("DEBUG(%s): applied timestamp for reqIndex(%d) frameCnt(%d) (%lld)", __FUNCTION__,
be494d19 781 index, frameCnt, currentEntry->internal_shot.shot.dm.sensor.timeStamp);
13d8c7b4
SK		 782}
783
5506cebf
SK		 784
785nsecs_t RequestManager::GetTimestampByFrameCnt(int frameCnt)
786{
787 int index = FindEntryIndexByFrameCnt(frameCnt);
788 if (index == -1) {
789 ALOGE("ERR(%s): Cannot find entry for frameCnt(%d) returning saved time(%lld)", __FUNCTION__, frameCnt, m_lastTimeStamp);
790 return m_lastTimeStamp;
791 }
792 else
793 return GetTimestamp(index);
794}
795
796nsecs_t RequestManager::GetTimestamp(int index)
13d8c7b4 797{
5f643a75 798 Mutex::Autolock lock(m_requestMutex);
eed7ed1b
SK		 799 if (index < 0 || index >= NUM_MAX_REQUEST_MGR_ENTRY) {
800 ALOGE("ERR(%s): Request entry outside of bounds (%d)", __FUNCTION__, index);
9dd63e1f
SK		 801 return 0;
802 }
803
13d8c7b4 804 request_manager_entry * currentEntry = &(entries[index]);
5f643a75 805 nsecs_t frameTime = currentEntry->internal_shot.shot.dm.sensor.timeStamp;
5506cebf
SK		 806 if (frameTime == 0) {
807 ALOGV("DEBUG(%s): timestamp null, returning saved value", __FUNCTION__);
808 frameTime = m_lastTimeStamp;
809 }
9dd63e1f 810 ALOGV("DEBUG(%s): Returning timestamp for reqIndex(%d) (%lld)", __FUNCTION__, index, frameTime);
13d8c7b4
SK		 811 return frameTime;
812}
813
9dd63e1f
SK		 814int RequestManager::FindFrameCnt(struct camera2_shot_ext * shot_ext)
815{
ad37861e
SK		 816 int i;
817
be494d19 818 if (m_numOfEntries == 0) {
5c88d1f2 819 CAM_LOGD("DBG(%s): No Entry found", __FUNCTION__);
be494d19
SK		 820 return -1;
821 }
ad37861e 822
be494d19 823 for (i = 0 ; i < NUM_MAX_REQUEST_MGR_ENTRY ; i++) {
ad37861e 824 if(entries[i].internal_shot.shot.ctl.request.frameCount != shot_ext->shot.ctl.request.frameCount)
be494d19 825 continue;
ad37861e
SK		 826
827 if (entries[i].status == REQUESTED) {
828 entries[i].status = CAPTURED;
829 return entries[i].internal_shot.shot.ctl.request.frameCount;
be494d19 830 }
5c88d1f2 831 CAM_LOGE("ERR(%s): frameCount(%d), index(%d), status(%d)", __FUNCTION__, shot_ext->shot.ctl.request.frameCount, i, entries[i].status);
ad37861e 832
be494d19 833 }
5c88d1f2 834 CAM_LOGD("(%s): No Entry found frame count(%d)", __FUNCTION__, shot_ext->shot.ctl.request.frameCount);
ad37861e 835
be494d19 836 return -1;
9dd63e1f 837}
13d8c7b4 838
b5237e6b
SK		 839void RequestManager::SetInitialSkip(int count)
840{
841 ALOGV("(%s): Pipeline Restarting. setting cnt(%d) - current(%d)", __FUNCTION__, count, m_sensorPipelineSkipCnt);
842 if (count > m_sensorPipelineSkipCnt)
843 m_sensorPipelineSkipCnt = count;
844}
845
ad37861e
SK		 846int RequestManager::GetSkipCnt()
847{
848 ALOGV("(%s): skip cnt(%d)", __FUNCTION__, m_sensorPipelineSkipCnt);
849 if (m_sensorPipelineSkipCnt == 0)
850 return m_sensorPipelineSkipCnt;
851 else
852 return --m_sensorPipelineSkipCnt;
853}
854
13d8c7b4
SK		 855void RequestManager::Dump(void)
856{
13d8c7b4
SK		 857 int i = 0;
858 request_manager_entry * currentEntry;
ad37861e 859 ALOGD("## Dump totalentry(%d), insert(%d), processing(%d), frame(%d)",
13d8c7b4
SK		 860 m_numOfEntries,m_entryInsertionIndex,m_entryProcessingIndex, m_entryFrameOutputIndex);
861
862 for (i = 0 ; i < NUM_MAX_REQUEST_MGR_ENTRY ; i++) {
863 currentEntry = &(entries[i]);
5506cebf 864 ALOGD("[%2d] status[%d] frameCnt[%3d] numOutput[%d] outstream[0]-%x ", i,
be494d19 865 currentEntry->status, currentEntry->internal_shot.shot.ctl.request.frameCount,
ad37861e 866 currentEntry->output_stream_count,
5506cebf 867 currentEntry->internal_shot.shot.ctl.request.outputStreams[0]);
13d8c7b4
SK		 868 }
869}
c15a6b00 870
9dd63e1f
SK		 871int RequestManager::GetNextIndex(int index)
872{
873 index++;
874 if (index >= NUM_MAX_REQUEST_MGR_ENTRY)
875 index = 0;
876
877 return index;
878}
879
6044e509 880ExynosCameraHWInterface2::ExynosCameraHWInterface2(int cameraId, camera2_device_t *dev, ExynosCamera2 * camera, int *openInvalid):
c15a6b00
JS		 881 m_requestQueueOps(NULL),
882 m_frameQueueOps(NULL),
883 m_callbackCookie(NULL),
884 m_numOfRemainingReqInSvc(0),
885 m_isRequestQueuePending(false),
13d8c7b4 886 m_isRequestQueueNull(true),
ad37861e 887 m_isIspStarted(false),
13d8c7b4 888 m_ionCameraClient(0),
308291de 889 m_zoomRatio(1),
9dd63e1f
SK		 890 m_scp_closing(false),
891 m_scp_closed(false),
0f26b20f
SK		 892 m_afState(HAL_AFSTATE_INACTIVE),
893 m_afMode(NO_CHANGE),
894 m_afMode2(NO_CHANGE),
5c88d1f2
C		 895#ifdef VDIS_ENABLE
896 m_vdisBubbleCnt(0),
897 m_vdisDupFrame(0),
898#endif
0f26b20f
SK		 899 m_IsAfModeUpdateRequired(false),
900 m_IsAfTriggerRequired(false),
901 m_IsAfLockRequired(false),
15fd8231 902 m_wideAspect(false),
b55ed664
SK		 903 m_scpOutputSignalCnt(0),
904 m_scpOutputImageCnt(0),
0f26b20f 905 m_afTriggerId(0),
8e2c2fdb
SK		 906 m_afPendingTriggerId(0),
907 m_afModeWaitingCnt(0),
9dd63e1f 908 m_halDevice(dev),
a15b4e3f 909 m_nightCaptureCnt(0),
2d5e6ec2
SK		 910 m_cameraId(cameraId),
911 m_thumbNailW(160),
912 m_thumbNailH(120)
13d8c7b4 913{
ed4ad5fe 914 ALOGD("(%s): ENTER", __FUNCTION__);
c15a6b00 915 int ret = 0;
6044e509 916 int res = 0;
c15a6b00 917
13d8c7b4 918 m_exynosPictureCSC = NULL;
9dd63e1f 919 m_exynosVideoCSC = NULL;
13d8c7b4 920
c15a6b00
JS		 921 if (!m_grallocHal) {
922 ret = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, (const hw_module_t **)&m_grallocHal);
923 if (ret)
13d8c7b4
SK		 924 ALOGE("ERR(%s):Fail on loading gralloc HAL", __FUNCTION__);
925 }
c15a6b00 926
daa1fcd6 927 m_camera2 = camera;
c15a6b00
JS		 928 m_ionCameraClient = createIonClient(m_ionCameraClient);
929 if(m_ionCameraClient == 0)
13d8c7b4 930 ALOGE("ERR(%s):Fail on ion_client_create", __FUNCTION__);
c15a6b00 931
9dd63e1f
SK		 932
933 m_BayerManager = new BayerBufManager();
c15a6b00 934 m_mainThread = new MainThread(this);
52f54308 935 m_requestManager = new RequestManager((SignalDrivenThread*)(m_mainThread.get()));
6044e509
SK		 936 *openInvalid = InitializeISPChain();
937 if (*openInvalid < 0) {
ed4ad5fe 938 ALOGD("(%s): ISP chain init failed. exiting", __FUNCTION__);
6044e509
SK		 939 // clean process
940 // 1. close video nodes
941 // SCP
5506cebf 942 res = exynos_v4l2_close(m_camera_info.scp.fd);
6044e509
SK		 943 if (res != NO_ERROR ) {
944 ALOGE("ERR(%s): exynos_v4l2_close failed(%d)",__FUNCTION__ , res);
945 }
946 // SCC
947 res = exynos_v4l2_close(m_camera_info.capture.fd);
948 if (res != NO_ERROR ) {
949 ALOGE("ERR(%s): exynos_v4l2_close failed(%d)",__FUNCTION__ , res);
950 }
951 // Sensor
952 res = exynos_v4l2_close(m_camera_info.sensor.fd);
953 if (res != NO_ERROR ) {
954 ALOGE("ERR(%s): exynos_v4l2_close failed(%d)",__FUNCTION__ , res);
955 }
956 // ISP
957 res = exynos_v4l2_close(m_camera_info.isp.fd);
958 if (res != NO_ERROR ) {
959 ALOGE("ERR(%s): exynos_v4l2_close failed(%d)",__FUNCTION__ , res);
960 }
961 } else {
962 m_sensorThread = new SensorThread(this);
963 m_mainThread->Start("MainThread", PRIORITY_DEFAULT, 0);
ed4ad5fe 964 ALOGV("DEBUG(%s): created sensorthread ", __FUNCTION__);
52f54308 965
5506cebf
SK		 966 for (int i = 0 ; i < STREAM_ID_LAST+1 ; i++)
967 m_subStreams[i].type = SUBSTREAM_TYPE_NONE;
6044e509
SK		 968 CSC_METHOD cscMethod = CSC_METHOD_HW;
969 m_exynosPictureCSC = csc_init(cscMethod);
970 if (m_exynosPictureCSC == NULL)
971 ALOGE("ERR(%s): csc_init() fail", __FUNCTION__);
972 csc_set_hw_property(m_exynosPictureCSC, CSC_HW_PROPERTY_FIXED_NODE, PICTURE_GSC_NODE_NUM);
15fd8231 973
6044e509
SK		 974 m_exynosVideoCSC = csc_init(cscMethod);
975 if (m_exynosVideoCSC == NULL)
976 ALOGE("ERR(%s): csc_init() fail", __FUNCTION__);
977 csc_set_hw_property(m_exynosVideoCSC, CSC_HW_PROPERTY_FIXED_NODE, VIDEO_GSC_NODE_NUM);
9dd63e1f 978
6044e509 979 m_setExifFixedAttribute();
9a710a45
YJ		 980
981 // contol information clear
982 // flash
983 m_ctlInfo.flash.i_flashMode = AA_AEMODE_ON;
984 m_ctlInfo.flash.m_afFlashDoneFlg= false;
9a710a45 985 m_ctlInfo.flash.m_flashEnableFlg = false;
9a710a45
YJ		 986 m_ctlInfo.flash.m_flashFrameCount = 0;
987 m_ctlInfo.flash.m_flashCnt = 0;
988 m_ctlInfo.flash.m_flashTimeOut = 0;
caea49e6
YJ		 989 m_ctlInfo.flash.m_flashDecisionResult = false;
990 m_ctlInfo.flash.m_flashTorchMode = false;
e117f756
YJ		 991 m_ctlInfo.flash.m_precaptureState = 0;
992 m_ctlInfo.flash.m_precaptureTriggerId = 0;
993 //ae
994 m_ctlInfo.ae.m_aeCnt = IS_COMMAND_NONE;
995 // awb
996 m_ctlInfo.awb.i_awbMode = AA_AWBMODE_OFF;
997 m_ctlInfo.awb.m_awbCnt = IS_COMMAND_NONE;
6044e509 998 }
ed4ad5fe 999 ALOGD("(%s): EXIT", __FUNCTION__);
c15a6b00
JS		 1000}
1001
1002ExynosCameraHWInterface2::~ExynosCameraHWInterface2()
1003{
ed4ad5fe 1004 ALOGD("(%s): ENTER", __FUNCTION__);
c15a6b00 1005 this->release();
ed4ad5fe 1006 ALOGD("(%s): EXIT", __FUNCTION__);
c15a6b00
JS		 1007}
1008
1009void ExynosCameraHWInterface2::release()
1010{
13d8c7b4 1011 int i, res;
ed4ad5fe 1012 ALOGD("(HAL2::release): ENTER");
9dd63e1f 1013
ad37861e
SK		 1014 if (m_streamThreads[1] != NULL) {
1015 m_streamThreads[1]->release();
1016 m_streamThreads[1]->SetSignal(SIGNAL_THREAD_TERMINATE);
1017 }
1018
1019 if (m_streamThreads[0] != NULL) {
1020 m_streamThreads[0]->release();
1021 m_streamThreads[0]->SetSignal(SIGNAL_THREAD_TERMINATE);
1022 }
1023
13d8c7b4
SK		 1024 if (m_sensorThread != NULL) {
1025 m_sensorThread->release();
13d8c7b4 1026 }
c15a6b00
JS		 1027
1028 if (m_mainThread != NULL) {
13d8c7b4 1029 m_mainThread->release();
13d8c7b4
SK		 1030 }
1031
13d8c7b4
SK		 1032 if (m_exynosPictureCSC)
1033 csc_deinit(m_exynosPictureCSC);
1034 m_exynosPictureCSC = NULL;
1035
9dd63e1f
SK		 1036 if (m_exynosVideoCSC)
1037 csc_deinit(m_exynosVideoCSC);
1038 m_exynosVideoCSC = NULL;
1039
ad37861e
SK		 1040 if (m_streamThreads[1] != NULL) {
1041 while (!m_streamThreads[1]->IsTerminated())
1042 {
ed4ad5fe 1043 ALOGD("(HAL2::release): Waiting for (indirect) stream thread 1 termination");
ad37861e
SK		 1044 usleep(100000);
1045 }
1046 m_streamThreads[1] = NULL;
1047 }
1048
1049 if (m_streamThreads[0] != NULL) {
1050 while (!m_streamThreads[0]->IsTerminated())
1051 {
ed4ad5fe 1052 ALOGD("(HAL2::release): Waiting for (indirect) stream thread 0 termination");
ad37861e
SK		 1053 usleep(100000);
1054 }
1055 m_streamThreads[0] = NULL;
1056 }
1057
9dd63e1f
SK		 1058 if (m_sensorThread != NULL) {
1059 while (!m_sensorThread->IsTerminated())
ad37861e 1060 {
ed4ad5fe 1061 ALOGD("(HAL2::release): Waiting for (indirect) sensor thread termination");
ad37861e
SK		 1062 usleep(100000);
1063 }
9dd63e1f
SK		 1064 m_sensorThread = NULL;
1065 }
1066
ad37861e 1067 if (m_mainThread != NULL) {
9dd63e1f 1068 while (!m_mainThread->IsTerminated())
ad37861e 1069 {
ed4ad5fe 1070 ALOGD("(HAL2::release): Waiting for (indirect) main thread termination");
ad37861e
SK		 1071 usleep(100000);
1072 }
9dd63e1f
SK		 1073 m_mainThread = NULL;
1074 }
1075
15fd8231
SK		 1076 if (m_requestManager != NULL) {
1077 delete m_requestManager;
1078 m_requestManager = NULL;
1079 }
1080
1081 if (m_BayerManager != NULL) {
1082 delete m_BayerManager;
1083 m_BayerManager = NULL;
1084 }
15fd8231 1085 for (i = 0; i < NUM_BAYER_BUFFERS; i++)
c15a6b00
JS		 1086 freeCameraMemory(&m_camera_info.sensor.buffer[i], m_camera_info.sensor.planes);
1087
ac8c2060 1088 for (i = 0; i < NUM_SCC_BUFFERS; i++)
c15a6b00
JS		 1089 freeCameraMemory(&m_camera_info.capture.buffer[i], m_camera_info.capture.planes);
1090
9dd63e1f 1091 ALOGV("DEBUG(%s): calling exynos_v4l2_close - sensor", __FUNCTION__);
13d8c7b4
SK		 1092 res = exynos_v4l2_close(m_camera_info.sensor.fd);
1093 if (res != NO_ERROR ) {
9dd63e1f 1094 ALOGE("ERR(%s): exynos_v4l2_close failed(%d)",__FUNCTION__ , res);
13d8c7b4
SK		 1095 }
1096
9dd63e1f 1097 ALOGV("DEBUG(%s): calling exynos_v4l2_close - isp", __FUNCTION__);
13d8c7b4
SK		 1098 res = exynos_v4l2_close(m_camera_info.isp.fd);
1099 if (res != NO_ERROR ) {
9dd63e1f 1100 ALOGE("ERR(%s): exynos_v4l2_close failed(%d)",__FUNCTION__ , res);
13d8c7b4
SK		 1101 }
1102
9dd63e1f 1103 ALOGV("DEBUG(%s): calling exynos_v4l2_close - capture", __FUNCTION__);
13d8c7b4
SK		 1104 res = exynos_v4l2_close(m_camera_info.capture.fd);
1105 if (res != NO_ERROR ) {
9dd63e1f 1106 ALOGE("ERR(%s): exynos_v4l2_close failed(%d)",__FUNCTION__ , res);
13d8c7b4
SK		 1107 }
1108
9dd63e1f 1109 ALOGV("DEBUG(%s): calling exynos_v4l2_close - scp", __FUNCTION__);
5506cebf 1110 res = exynos_v4l2_close(m_camera_info.scp.fd);
13d8c7b4 1111 if (res != NO_ERROR ) {
9dd63e1f 1112 ALOGE("ERR(%s): exynos_v4l2_close failed(%d)",__FUNCTION__ , res);
13d8c7b4 1113 }
9dd63e1f 1114 ALOGV("DEBUG(%s): calling deleteIonClient", __FUNCTION__);
c15a6b00 1115 deleteIonClient(m_ionCameraClient);
ad37861e 1116
ed4ad5fe 1117 ALOGD("(HAL2::release): EXIT");
ad37861e
SK		 1118}
1119
6044e509 1120int ExynosCameraHWInterface2::InitializeISPChain()
ad37861e
SK		 1121{
1122 char node_name[30];
1123 int fd = 0;
1124 int i;
6044e509 1125 int ret = 0;
ad37861e
SK		 1126
1127 /* Open Sensor */
1128 memset(&node_name, 0x00, sizeof(char[30]));
1129 sprintf(node_name, "%s%d", NODE_PREFIX, 40);
1130 fd = exynos_v4l2_open(node_name, O_RDWR, 0);
1131
1132 if (fd < 0) {
1133 ALOGE("ERR(%s): failed to open sensor video node (%s) fd (%d)", __FUNCTION__,node_name, fd);
1134 }
1135 else {
1136 ALOGV("DEBUG(%s): sensor video node opened(%s) fd (%d)", __FUNCTION__,node_name, fd);
1137 }
1138 m_camera_info.sensor.fd = fd;
1139
1140 /* Open ISP */
1141 memset(&node_name, 0x00, sizeof(char[30]));
1142 sprintf(node_name, "%s%d", NODE_PREFIX, 41);
1143 fd = exynos_v4l2_open(node_name, O_RDWR, 0);
1144
1145 if (fd < 0) {
1146 ALOGE("ERR(%s): failed to open isp video node (%s) fd (%d)", __FUNCTION__,node_name, fd);
1147 }
1148 else {
1149 ALOGV("DEBUG(%s): isp video node opened(%s) fd (%d)", __FUNCTION__,node_name, fd);
1150 }
1151 m_camera_info.isp.fd = fd;
1152
1153 /* Open ScalerC */
1154 memset(&node_name, 0x00, sizeof(char[30]));
1155 sprintf(node_name, "%s%d", NODE_PREFIX, 42);
1156 fd = exynos_v4l2_open(node_name, O_RDWR, 0);
1157
1158 if (fd < 0) {
1159 ALOGE("ERR(%s): failed to open capture video node (%s) fd (%d)", __FUNCTION__,node_name, fd);
1160 }
1161 else {
1162 ALOGV("DEBUG(%s): capture video node opened(%s) fd (%d)", __FUNCTION__,node_name, fd);
1163 }
1164 m_camera_info.capture.fd = fd;
1165
1166 /* Open ScalerP */
1167 memset(&node_name, 0x00, sizeof(char[30]));
1168 sprintf(node_name, "%s%d", NODE_PREFIX, 44);
1169 fd = exynos_v4l2_open(node_name, O_RDWR, 0);
1170 if (fd < 0) {
1171 ALOGE("DEBUG(%s): failed to open preview video node (%s) fd (%d)", __FUNCTION__,node_name, fd);
1172 }
1173 else {
1174 ALOGV("DEBUG(%s): preview video node opened(%s) fd (%d)", __FUNCTION__,node_name, fd);
1175 }
5506cebf 1176 m_camera_info.scp.fd = fd;
ad37861e
SK		 1177
1178 if(m_cameraId == 0)
1179 m_camera_info.sensor_id = SENSOR_NAME_S5K4E5;
1180 else
1181 m_camera_info.sensor_id = SENSOR_NAME_S5K6A3;
1182
1183 memset(&m_camera_info.dummy_shot, 0x00, sizeof(struct camera2_shot_ext));
1184 m_camera_info.dummy_shot.shot.ctl.request.metadataMode = METADATA_MODE_FULL;
1185 m_camera_info.dummy_shot.shot.magicNumber = 0x23456789;
1186
1187 m_camera_info.dummy_shot.dis_bypass = 1;
1188 m_camera_info.dummy_shot.dnr_bypass = 1;
1189 m_camera_info.dummy_shot.fd_bypass = 1;
1190
1191 /*sensor setting*/
1192 m_camera_info.dummy_shot.shot.ctl.sensor.exposureTime = 0;
1193 m_camera_info.dummy_shot.shot.ctl.sensor.frameDuration = 0;
1194 m_camera_info.dummy_shot.shot.ctl.sensor.sensitivity = 0;
1195
1196 m_camera_info.dummy_shot.shot.ctl.scaler.cropRegion[0] = 0;
1197 m_camera_info.dummy_shot.shot.ctl.scaler.cropRegion[1] = 0;
1198
1199 /*request setting*/
1200 m_camera_info.dummy_shot.request_sensor = 1;
1201 m_camera_info.dummy_shot.request_scc = 0;
1202 m_camera_info.dummy_shot.request_scp = 0;
1203 m_camera_info.dummy_shot.shot.ctl.request.outputStreams[0] = 0;
ad37861e
SK		 1204
1205 m_camera_info.sensor.width = m_camera2->getSensorRawW();
1206 m_camera_info.sensor.height = m_camera2->getSensorRawH();
1207
1208 m_camera_info.sensor.format = V4L2_PIX_FMT_SBGGR16;
1209 m_camera_info.sensor.planes = 2;
1210 m_camera_info.sensor.buffers = NUM_BAYER_BUFFERS;
1211 m_camera_info.sensor.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
1212 m_camera_info.sensor.memory = V4L2_MEMORY_DMABUF;
ad37861e
SK		 1213
1214 for(i = 0; i < m_camera_info.sensor.buffers; i++){
1215 initCameraMemory(&m_camera_info.sensor.buffer[i], m_camera_info.sensor.planes);
1216 m_camera_info.sensor.buffer[i].size.extS[0] = m_camera_info.sensor.width*m_camera_info.sensor.height*2;
1217 m_camera_info.sensor.buffer[i].size.extS[1] = 8*1024; // HACK, driver use 8*1024, should be use predefined value
5506cebf 1218 allocCameraMemory(m_ionCameraClient, &m_camera_info.sensor.buffer[i], m_camera_info.sensor.planes, 1<<1);
ad37861e
SK		 1219 }
1220
1221 m_camera_info.isp.width = m_camera_info.sensor.width;
1222 m_camera_info.isp.height = m_camera_info.sensor.height;
1223 m_camera_info.isp.format = m_camera_info.sensor.format;
1224 m_camera_info.isp.planes = m_camera_info.sensor.planes;
1225 m_camera_info.isp.buffers = m_camera_info.sensor.buffers;
1226 m_camera_info.isp.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
1227 m_camera_info.isp.memory = V4L2_MEMORY_DMABUF;
ad37861e
SK		 1228
1229 for(i = 0; i < m_camera_info.isp.buffers; i++){
1230 initCameraMemory(&m_camera_info.isp.buffer[i], m_camera_info.isp.planes);
1231 m_camera_info.isp.buffer[i].size.extS[0] = m_camera_info.sensor.buffer[i].size.extS[0];
1232 m_camera_info.isp.buffer[i].size.extS[1] = m_camera_info.sensor.buffer[i].size.extS[1];
1233 m_camera_info.isp.buffer[i].fd.extFd[0] = m_camera_info.sensor.buffer[i].fd.extFd[0];
1234 m_camera_info.isp.buffer[i].fd.extFd[1] = m_camera_info.sensor.buffer[i].fd.extFd[1];
1235 m_camera_info.isp.buffer[i].virt.extP[0] = m_camera_info.sensor.buffer[i].virt.extP[0];
1236 m_camera_info.isp.buffer[i].virt.extP[1] = m_camera_info.sensor.buffer[i].virt.extP[1];
1237 };
1238
1239 /* init ISP */
6044e509
SK		 1240 ret = cam_int_s_input(&(m_camera_info.isp), m_camera_info.sensor_id);
1241 if (ret < 0) {
1242 ALOGE("ERR(%s): cam_int_s_input(%d) failed!!!! ", __FUNCTION__, m_camera_info.sensor_id);
1243 return false;
1244 }
ad37861e
SK		 1245 cam_int_s_fmt(&(m_camera_info.isp));
1246 ALOGV("DEBUG(%s): isp calling reqbuf", __FUNCTION__);
1247 cam_int_reqbufs(&(m_camera_info.isp));
1248 ALOGV("DEBUG(%s): isp calling querybuf", __FUNCTION__);
1249 ALOGV("DEBUG(%s): isp mem alloc done", __FUNCTION__);
1250
1251 /* init Sensor */
1252 cam_int_s_input(&(m_camera_info.sensor), m_camera_info.sensor_id);
1253 ALOGV("DEBUG(%s): sensor s_input done", __FUNCTION__);
1254 if (cam_int_s_fmt(&(m_camera_info.sensor))< 0) {
1255 ALOGE("ERR(%s): sensor s_fmt fail", __FUNCTION__);
1256 }
1257 ALOGV("DEBUG(%s): sensor s_fmt done", __FUNCTION__);
1258 cam_int_reqbufs(&(m_camera_info.sensor));
1259 ALOGV("DEBUG(%s): sensor reqbuf done", __FUNCTION__);
1260 for (i = 0; i < m_camera_info.sensor.buffers; i++) {
1261 ALOGV("DEBUG(%s): sensor initial QBUF [%d]", __FUNCTION__, i);
ad37861e
SK		 1262 m_camera_info.dummy_shot.shot.ctl.sensor.frameDuration = 33*1000*1000; // apply from frame #1
1263 m_camera_info.dummy_shot.shot.ctl.request.frameCount = -1;
52f54308
SK		 1264 memcpy( m_camera_info.sensor.buffer[i].virt.extP[1], &(m_camera_info.dummy_shot),
1265 sizeof(struct camera2_shot_ext));
ad37861e 1266 }
52f54308
SK		 1267
1268 for (i = 0; i < NUM_MIN_SENSOR_QBUF; i++)
1269 cam_int_qbuf(&(m_camera_info.sensor), i);
1270
1271 for (i = NUM_MIN_SENSOR_QBUF; i < m_camera_info.sensor.buffers; i++)
1272 m_requestManager->pushSensorQ(i);
1273
5506cebf 1274 ALOGV("== stream_on :: sensor");
ad37861e 1275 cam_int_streamon(&(m_camera_info.sensor));
5506cebf 1276 m_camera_info.sensor.status = true;
ad37861e
SK		 1277
1278 /* init Capture */
1279 m_camera_info.capture.width = m_camera2->getSensorW();
1280 m_camera_info.capture.height = m_camera2->getSensorH();
1281 m_camera_info.capture.format = V4L2_PIX_FMT_YUYV;
feb7df4c
SK		 1282#ifdef ENABLE_FRAME_SYNC
1283 m_camera_info.capture.planes = 2;
1284#else
ad37861e 1285 m_camera_info.capture.planes = 1;
feb7df4c 1286#endif
ac8c2060 1287 m_camera_info.capture.buffers = NUM_SCC_BUFFERS;
ad37861e
SK		 1288 m_camera_info.capture.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
1289 m_camera_info.capture.memory = V4L2_MEMORY_DMABUF;
ad37861e 1290
5506cebf
SK		 1291 m_camera_info.capture.status = false;
1292
1293 return true;
1294}
1295
1296void ExynosCameraHWInterface2::StartSCCThread(bool threadExists)
1297{
1298 ALOGV("(%s)", __FUNCTION__);
1299 StreamThread *AllocatedStream;
1300 stream_parameters_t newParameters;
1301 uint32_t format_actual;
1302 int numRegisteredStream = 0;
1303
1304
1305 if (!threadExists) {
1306 m_streamThreads[1] = new StreamThread(this, 1);
1307 }
1308 AllocatedStream = (StreamThread*)(m_streamThreads[1].get());
1309 if (!threadExists)
1310 m_streamThreadInitialize((SignalDrivenThread*)AllocatedStream);
1311 AllocatedStream->m_index = 1;
1312
1313 format_actual = HAL_PIXEL_FORMAT_YCbCr_422_I; // YUYV
1314
1315 newParameters.width = m_camera2->getSensorW();
1316 newParameters.height = m_camera2->getSensorH();
1317 newParameters.format = format_actual;
1318 newParameters.streamOps = NULL;
ac8c2060 1319 newParameters.numHwBuffers = NUM_SCC_BUFFERS;
feb7df4c 1320#ifdef ENABLE_FRAME_SYNC
5506cebf 1321 newParameters.planes = 2;
2adfa429 1322#else
5506cebf 1323 newParameters.planes = 1;
2adfa429 1324#endif
ad37861e 1325
5506cebf
SK		 1326 newParameters.numSvcBufsInHal = 0;
1327
1328 newParameters.node = &m_camera_info.capture;
1329
1330 AllocatedStream->streamType = STREAM_TYPE_INDIRECT;
1331 AllocatedStream->m_numRegisteredStream = numRegisteredStream;
1332 ALOGV("(%s): m_numRegisteredStream = %d", __FUNCTION__, AllocatedStream->m_numRegisteredStream);
1333
1334 for (int i = 0; i < m_camera_info.capture.buffers; i++){
1335 if (!threadExists) {
1336 initCameraMemory(&m_camera_info.capture.buffer[i], newParameters.node->planes);
1337 m_camera_info.capture.buffer[i].size.extS[0] = m_camera_info.capture.width*m_camera_info.capture.height*2;
1338#ifdef ENABLE_FRAME_SYNC
1339 m_camera_info.capture.buffer[i].size.extS[1] = 4*1024; // HACK, driver use 4*1024, should be use predefined value
1340 allocCameraMemory(m_ionCameraClient, &m_camera_info.capture.buffer[i], m_camera_info.capture.planes, 1<<1);
1341#else
1342 allocCameraMemory(m_ionCameraClient, &m_camera_info.capture.buffer[i], m_camera_info.capture.planes);
1343#endif
1344 }
1345 }
1346 cam_int_s_input(newParameters.node, m_camera_info.sensor_id);
ac8c2060 1347 m_camera_info.capture.buffers = NUM_SCC_BUFFERS;
5506cebf 1348 cam_int_s_fmt(newParameters.node);
ad37861e 1349 ALOGV("DEBUG(%s): capture calling reqbuf", __FUNCTION__);
5506cebf 1350 cam_int_reqbufs(newParameters.node);
ad37861e
SK		 1351 ALOGV("DEBUG(%s): capture calling querybuf", __FUNCTION__);
1352
5506cebf 1353 for (int i = 0; i < newParameters.node->buffers; i++) {
ad37861e 1354 ALOGV("DEBUG(%s): capture initial QBUF [%d]", __FUNCTION__, i);
5506cebf
SK		 1355 cam_int_qbuf(newParameters.node, i);
1356 newParameters.svcBufStatus[i] = ON_DRIVER;
ad37861e
SK		 1357 }
1358
1359 ALOGV("== stream_on :: capture");
5506cebf 1360 if (cam_int_streamon(newParameters.node) < 0) {
15fd8231
SK		 1361 ALOGE("ERR(%s): capture stream on fail", __FUNCTION__);
1362 } else {
1363 m_camera_info.capture.status = true;
1364 }
6044e509 1365
5506cebf
SK		 1366 AllocatedStream->setParameter(&newParameters);
1367 AllocatedStream->m_activated = true;
1368 AllocatedStream->m_isBufferInit = true;
ad37861e
SK		 1369}
1370
1371void ExynosCameraHWInterface2::StartISP()
1372{
ad37861e
SK		 1373 ALOGV("== stream_on :: isp");
1374 cam_int_streamon(&(m_camera_info.isp));
ad37861e 1375 exynos_v4l2_s_ctrl(m_camera_info.sensor.fd, V4L2_CID_IS_S_STREAM, IS_ENABLE_STREAM);
13d8c7b4
SK		 1376}
1377
c15a6b00
JS		 1378int ExynosCameraHWInterface2::getCameraId() const
1379{
9dd63e1f 1380 return m_cameraId;
c15a6b00 1381}
c15a6b00
JS		 1382
1383int ExynosCameraHWInterface2::setRequestQueueSrcOps(const camera2_request_queue_src_ops_t *request_src_ops)
1384{
13d8c7b4 1385 ALOGV("DEBUG(%s):", __FUNCTION__);
c15a6b00
JS		 1386 if ((NULL != request_src_ops) && (NULL != request_src_ops->dequeue_request)
1387 && (NULL != request_src_ops->free_request) && (NULL != request_src_ops->request_count)) {
1388 m_requestQueueOps = (camera2_request_queue_src_ops_t*)request_src_ops;
1389 return 0;
1390 }
1391 else {
13d8c7b4 1392 ALOGE("DEBUG(%s):setRequestQueueSrcOps : NULL arguments", __FUNCTION__);
c15a6b00
JS		 1393 return 1;
1394 }
1395}
1396
1397int ExynosCameraHWInterface2::notifyRequestQueueNotEmpty()
1398{
5506cebf
SK		 1399 int i = 0;
1400
b5237e6b 1401 ALOGV("DEBUG(%s):setting [SIGNAL_MAIN_REQ_Q_NOT_EMPTY] current(%d)", __FUNCTION__, m_requestManager->GetNumEntries());
c15a6b00 1402 if ((NULL==m_frameQueueOps)|| (NULL==m_requestQueueOps)) {
13d8c7b4 1403 ALOGE("DEBUG(%s):queue ops NULL. ignoring request", __FUNCTION__);
c15a6b00
JS		 1404 return 0;
1405 }
13d8c7b4 1406 m_isRequestQueueNull = false;
0f26b20f
SK		 1407 if (m_requestManager->GetNumEntries() == 0)
1408 m_requestManager->SetInitialSkip(5);
5506cebf
SK		 1409
1410 if (m_isIspStarted == false) {
1411 /* isp */
1412 m_camera_info.sensor.buffers = NUM_BAYER_BUFFERS;
1413 m_camera_info.isp.buffers = m_camera_info.sensor.buffers;
1414 cam_int_s_fmt(&(m_camera_info.isp));
1415 cam_int_reqbufs(&(m_camera_info.isp));
1416
1417 /* sensor */
1418 if (m_camera_info.sensor.status == false) {
1419 cam_int_s_fmt(&(m_camera_info.sensor));
1420 cam_int_reqbufs(&(m_camera_info.sensor));
1421
1422 for (i = 0; i < m_camera_info.sensor.buffers; i++) {
1423 ALOGV("DEBUG(%s): sensor initial QBUF [%d]", __FUNCTION__, i);
1424 m_camera_info.dummy_shot.shot.ctl.sensor.frameDuration = 33*1000*1000; // apply from frame #1
1425 m_camera_info.dummy_shot.shot.ctl.request.frameCount = -1;
1426 memcpy( m_camera_info.sensor.buffer[i].virt.extP[1], &(m_camera_info.dummy_shot),
1427 sizeof(struct camera2_shot_ext));
1428 }
1429 for (i = 0; i < NUM_MIN_SENSOR_QBUF; i++)
1430 cam_int_qbuf(&(m_camera_info.sensor), i);
1431
1432 for (i = NUM_MIN_SENSOR_QBUF; i < m_camera_info.sensor.buffers; i++)
1433 m_requestManager->pushSensorQ(i);
1434 ALOGV("DEBUG(%s): calling sensor streamon", __FUNCTION__);
1435 cam_int_streamon(&(m_camera_info.sensor));
1436 m_camera_info.sensor.status = true;
1437 }
1438 }
1439 if (!(m_streamThreads[1].get())) {
1440 ALOGV("DEBUG(%s): stream thread 1 not exist. starting without stream", __FUNCTION__);
1441 StartSCCThread(false);
1442 } else {
1443 if (m_streamThreads[1]->m_activated == false) {
1444 ALOGV("DEBUG(%s): stream thread 1 suspended. restarting", __FUNCTION__);
1445 StartSCCThread(true);
1446 } else {
1447 if (m_camera_info.capture.status == false) {
ac8c2060 1448 m_camera_info.capture.buffers = NUM_SCC_BUFFERS;
5506cebf
SK		 1449 cam_int_s_fmt(&(m_camera_info.capture));
1450 ALOGV("DEBUG(%s): capture calling reqbuf", __FUNCTION__);
1451 cam_int_reqbufs(&(m_camera_info.capture));
1452 ALOGV("DEBUG(%s): capture calling querybuf", __FUNCTION__);
1453
1454 for (int i = 0; i < m_camera_info.capture.buffers; i++) {
1455 ALOGV("DEBUG(%s): capture initial QBUF [%d]", __FUNCTION__, i);
1456 cam_int_qbuf(&(m_camera_info.capture), i);
1457 }
1458 ALOGV("== stream_on :: capture");
1459 if (cam_int_streamon(&(m_camera_info.capture)) < 0) {
1460 ALOGE("ERR(%s): capture stream on fail", __FUNCTION__);
1461 } else {
1462 m_camera_info.capture.status = true;
1463 }
1464 }
1465 }
1466 }
1467 if (m_isIspStarted == false) {
1468 StartISP();
1469 ALOGV("DEBUG(%s):starting sensor thread", __FUNCTION__);
1470 m_requestManager->SetInitialSkip(5);
1471 m_sensorThread->Start("SensorThread", PRIORITY_DEFAULT, 0);
1472 m_isIspStarted = true;
1473 }
c15a6b00
JS		 1474 m_mainThread->SetSignal(SIGNAL_MAIN_REQ_Q_NOT_EMPTY);
1475 return 0;
1476}
1477
1478int ExynosCameraHWInterface2::setFrameQueueDstOps(const camera2_frame_queue_dst_ops_t *frame_dst_ops)
1479{
13d8c7b4 1480 ALOGV("DEBUG(%s):", __FUNCTION__);
c15a6b00
JS		 1481 if ((NULL != frame_dst_ops) && (NULL != frame_dst_ops->dequeue_frame)
1482 && (NULL != frame_dst_ops->cancel_frame) && (NULL !=frame_dst_ops->enqueue_frame)) {
1483 m_frameQueueOps = (camera2_frame_queue_dst_ops_t *)frame_dst_ops;
1484 return 0;
1485 }
1486 else {
13d8c7b4 1487 ALOGE("DEBUG(%s):setFrameQueueDstOps : NULL arguments", __FUNCTION__);
c15a6b00
JS		 1488 return 1;
1489 }
1490}
1491
1492int ExynosCameraHWInterface2::getInProgressCount()
1493{
1494 int inProgressCount = m_requestManager->GetNumEntries();
13d8c7b4 1495 ALOGV("DEBUG(%s): # of dequeued req (%d)", __FUNCTION__, inProgressCount);
c15a6b00
JS		 1496 return inProgressCount;
1497}
1498
1499int ExynosCameraHWInterface2::flushCapturesInProgress()
1500{
1501 return 0;
1502}
1503
c15a6b00
JS		 1504int ExynosCameraHWInterface2::constructDefaultRequest(int request_template, camera_metadata_t **request)
1505{
13d8c7b4 1506 ALOGV("DEBUG(%s): making template (%d) ", __FUNCTION__, request_template);
c15a6b00
JS		 1507
1508 if (request == NULL) return BAD_VALUE;
1509 if (request_template < 0 || request_template >= CAMERA2_TEMPLATE_COUNT) {
1510 return BAD_VALUE;
1511 }
1512 status_t res;
1513 // Pass 1, calculate size and allocate
daa1fcd6 1514 res = m_camera2->constructDefaultRequest(request_template,
c15a6b00
JS		 1515 request,
1516 true);
1517 if (res != OK) {
1518 return res;
1519 }
1520 // Pass 2, build request
daa1fcd6 1521 res = m_camera2->constructDefaultRequest(request_template,
c15a6b00
JS		 1522 request,
1523 false);
1524 if (res != OK) {
1525 ALOGE("Unable to populate new request for template %d",
1526 request_template);
1527 }
1528
1529 return res;
1530}
1531
1532int ExynosCameraHWInterface2::allocateStream(uint32_t width, uint32_t height, int format, const camera2_stream_ops_t *stream_ops,
1533 uint32_t *stream_id, uint32_t *format_actual, uint32_t *usage, uint32_t *max_buffers)
1534{
ed4ad5fe 1535 ALOGD("(%s): stream width(%d) height(%d) format(%x)", __FUNCTION__, width, height, format);
5506cebf 1536 bool useDirectOutput = false;
13d8c7b4
SK		 1537 StreamThread *AllocatedStream;
1538 stream_parameters_t newParameters;
5506cebf
SK		 1539 substream_parameters_t *subParameters;
1540 StreamThread *parentStream;
1541 status_t res;
1542 int allocCase = 0;
c15a6b00 1543
5506cebf
SK		 1544 if ((format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED || format == CAMERA2_HAL_PIXEL_FORMAT_OPAQUE) &&
1545 m_camera2->isSupportedResolution(width, height)) {
9dd63e1f
SK		 1546 if (!(m_streamThreads[0].get())) {
1547 ALOGV("DEBUG(%s): stream 0 not exist", __FUNCTION__);
1548 allocCase = 0;
13d8c7b4
SK		 1549 }
1550 else {
6bbb593a 1551 if ((m_streamThreads[0].get())->m_activated == true) {
9dd63e1f
SK		 1552 ALOGV("DEBUG(%s): stream 0 exists and activated.", __FUNCTION__);
1553 allocCase = 1;
1554 }
1555 else {
1556 ALOGV("DEBUG(%s): stream 0 exists and deactivated.", __FUNCTION__);
1557 allocCase = 2;
1558 }
13d8c7b4 1559 }
5506cebf
SK		 1560
1561 // TODO : instead of that, use calculate aspect ratio and selection with calculated ratio.
1562 if ((width == 1920 && height == 1080) || (width == 1280 && height == 720)
1563 || (width == 720 && height == 480) || (width == 1440 && height == 960)
1564 || (width == 1344 && height == 896)) {
15fd8231 1565 m_wideAspect = true;
5506cebf 1566 } else {
15fd8231
SK		 1567 m_wideAspect = false;
1568 }
1569 ALOGV("DEBUG(%s): m_wideAspect (%d)", __FUNCTION__, m_wideAspect);
1570
9dd63e1f 1571 if (allocCase == 0 || allocCase == 2) {
5506cebf 1572 *stream_id = STREAM_ID_PREVIEW;
9dd63e1f 1573
5506cebf 1574 m_streamThreads[0] = new StreamThread(this, *stream_id);
9dd63e1f 1575
5506cebf
SK		 1576 AllocatedStream = (StreamThread*)(m_streamThreads[0].get());
1577 m_streamThreadInitialize((SignalDrivenThread*)AllocatedStream);
1578
1579 *format_actual = HAL_PIXEL_FORMAT_EXYNOS_YV12;
1580 *usage = GRALLOC_USAGE_SW_WRITE_OFTEN;
1581 *max_buffers = 6;
1582
1583 newParameters.width = width;
1584 newParameters.height = height;
1585 newParameters.format = *format_actual;
1586 newParameters.streamOps = stream_ops;
1587 newParameters.usage = *usage;
ac8c2060 1588 newParameters.numHwBuffers = NUM_SCP_BUFFERS;
5506cebf
SK		 1589 newParameters.numOwnSvcBuffers = *max_buffers;
1590 newParameters.planes = NUM_PLANES(*format_actual);
1591 newParameters.metaPlanes = 1;
1592 newParameters.numSvcBufsInHal = 0;
1593 newParameters.minUndequedBuffer = 4;
1594
1595 newParameters.node = &m_camera_info.scp;
1596 newParameters.node->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
1597 newParameters.node->memory = V4L2_MEMORY_DMABUF;
1598
1599 AllocatedStream->streamType = STREAM_TYPE_DIRECT;
1600 AllocatedStream->m_index = 0;
9dd63e1f
SK		 1601 AllocatedStream->setParameter(&newParameters);
1602 AllocatedStream->m_activated = true;
5506cebf
SK		 1603 AllocatedStream->m_numRegisteredStream = 1;
1604 ALOGV("(%s): m_numRegisteredStream = %d", __FUNCTION__, AllocatedStream->m_numRegisteredStream);
ad37861e
SK		 1605 m_requestManager->SetDefaultParameters(m_camera2->getSensorW());
1606 m_camera_info.dummy_shot.shot.ctl.scaler.cropRegion[2] = m_camera2->getSensorW();
5506cebf
SK		 1607 if (m_subStreams[STREAM_ID_RECORD].type != SUBSTREAM_TYPE_NONE)
1608 AllocatedStream->attachSubStream(STREAM_ID_RECORD, 10);
1609 if (m_subStreams[STREAM_ID_PRVCB].type != SUBSTREAM_TYPE_NONE)
1610 AllocatedStream->attachSubStream(STREAM_ID_PRVCB, 70);
9dd63e1f 1611 return 0;
5506cebf
SK		 1612 } else if (allocCase == 1) {
1613 *stream_id = STREAM_ID_RECORD;
1614
1615 subParameters = &m_subStreams[STREAM_ID_RECORD];
1616 memset(subParameters, 0, sizeof(substream_parameters_t));
1617
9dd63e1f
SK		 1618 parentStream = (StreamThread*)(m_streamThreads[0].get());
1619 if (!parentStream) {
1620 return 1;
9dd63e1f 1621 }
9dd63e1f 1622
804236a7 1623 *format_actual = HAL_PIXEL_FORMAT_YCbCr_420_SP; // NV12M
6bbb593a 1624 *usage = GRALLOC_USAGE_SW_WRITE_OFTEN;
2630679a 1625 *max_buffers = 6;
9dd63e1f 1626
5506cebf
SK		 1627 subParameters->type = SUBSTREAM_TYPE_RECORD;
1628 subParameters->width = width;
1629 subParameters->height = height;
1630 subParameters->format = *format_actual;
1631 subParameters->svcPlanes = NUM_PLANES(*format_actual);
1632 subParameters->streamOps = stream_ops;
1633 subParameters->usage = *usage;
1634 subParameters->numOwnSvcBuffers = *max_buffers;
1635 subParameters->numSvcBufsInHal = 0;
1636 subParameters->needBufferInit = false;
1637 subParameters->minUndequedBuffer = 2;
1638
1639 res = parentStream->attachSubStream(STREAM_ID_RECORD, 20);
1640 if (res != NO_ERROR) {
1641 ALOGE("(%s): substream attach failed. res(%d)", __FUNCTION__, res);
1642 return 1;
1643 }
1644 ALOGV("(%s): m_numRegisteredStream = %d", __FUNCTION__, parentStream->m_numRegisteredStream);
1645 ALOGV("(%s): Enabling Record", __FUNCTION__);
9dd63e1f
SK		 1646 return 0;
1647 }
13d8c7b4 1648 }
5506cebf
SK		 1649 else if ((format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED|| format == CAMERA2_HAL_PIXEL_FORMAT_OPAQUE)
1650 && (width == m_camera2->getSensorW()) && (height == m_camera2->getSensorH())) {
13d8c7b4 1651
5506cebf
SK		 1652 if (!(m_streamThreads[1].get())) {
1653 ALOGV("DEBUG(%s): stream thread 1 not exist", __FUNCTION__);
1654 useDirectOutput = true;
1655// createThread = true;
15fd8231
SK		 1656 }
1657 else {
5506cebf
SK		 1658 ALOGV("DEBUG(%s): stream thread 1 exists and deactivated.", __FUNCTION__);
1659// useDirectOutput = true;
1660// createThread = false;
1661 }
1662 if (useDirectOutput) {
1663 *stream_id = STREAM_ID_ZSL;
1664
1665 /*if (createThread)*/ {
1666 m_streamThreads[1] = new StreamThread(this, *stream_id);
15fd8231 1667 }
5506cebf
SK		 1668 AllocatedStream = (StreamThread*)(m_streamThreads[1].get());
1669 m_streamThreadInitialize((SignalDrivenThread*)AllocatedStream);
1670
1671 *format_actual = HAL_PIXEL_FORMAT_EXYNOS_YV12;
1672 *max_buffers = 6;
1673
1674 *format_actual = HAL_PIXEL_FORMAT_YCbCr_422_I; // YUYV
1675 *usage = GRALLOC_USAGE_SW_WRITE_OFTEN;
1676 *max_buffers = 6;
1677
1678 newParameters.width = width;
1679 newParameters.height = height;
1680 newParameters.format = *format_actual;
1681 newParameters.streamOps = stream_ops;
1682 newParameters.usage = *usage;
ac8c2060 1683 newParameters.numHwBuffers = NUM_SCC_BUFFERS;
5506cebf
SK		 1684 newParameters.numOwnSvcBuffers = *max_buffers;
1685 newParameters.planes = NUM_PLANES(*format_actual);
1686 newParameters.metaPlanes = 1;
1687
1688 newParameters.numSvcBufsInHal = 0;
1689 newParameters.minUndequedBuffer = 4;
1690
1691 newParameters.node = &m_camera_info.capture;
1692 newParameters.node->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
1693 newParameters.node->memory = V4L2_MEMORY_DMABUF;
1694
1695 AllocatedStream->streamType = STREAM_TYPE_DIRECT;
1696 AllocatedStream->m_index = 1;
1697 AllocatedStream->setParameter(&newParameters);
1698 AllocatedStream->m_activated = true;
1699 AllocatedStream->m_numRegisteredStream++;
1700 ALOGV("(%s): m_numRegisteredStream = %d", __FUNCTION__, AllocatedStream->m_numRegisteredStream);
1701 return 0;
15fd8231 1702 }
5506cebf
SK		 1703 }
1704 else if (format == HAL_PIXEL_FORMAT_BLOB
1705 && m_camera2->isSupportedJpegResolution(width, height)) {
1706 *stream_id = STREAM_ID_JPEG;
15fd8231 1707
5506cebf
SK		 1708 subParameters = &m_subStreams[*stream_id];
1709 memset(subParameters, 0, sizeof(substream_parameters_t));
9dd63e1f 1710
5506cebf
SK		 1711 if (!(m_streamThreads[1].get())) {
1712 ALOGV("DEBUG(%s): stream thread 1 not exist", __FUNCTION__);
1713 StartSCCThread(false);
1714 }
1715 else if (m_streamThreads[1]->m_activated == false) {
1716 ALOGV("DEBUG(%s): stream thread 1 suspended. restarting", __FUNCTION__);
1717 StartSCCThread(true);
1718 }
1719 parentStream = (StreamThread*)(m_streamThreads[1].get());
13d8c7b4
SK		 1720
1721 *format_actual = HAL_PIXEL_FORMAT_BLOB;
13d8c7b4 1722 *usage = GRALLOC_USAGE_SW_WRITE_OFTEN;
37e122d5 1723 *max_buffers = 4;
13d8c7b4 1724
5506cebf
SK		 1725 subParameters->type = SUBSTREAM_TYPE_JPEG;
1726 subParameters->width = width;
1727 subParameters->height = height;
1728 subParameters->format = *format_actual;
1729 subParameters->svcPlanes = 1;
1730 subParameters->streamOps = stream_ops;
1731 subParameters->usage = *usage;
1732 subParameters->numOwnSvcBuffers = *max_buffers;
1733 subParameters->numSvcBufsInHal = 0;
1734 subParameters->needBufferInit = false;
1735 subParameters->minUndequedBuffer = 2;
1736
1737 res = parentStream->attachSubStream(STREAM_ID_JPEG, 10);
1738 if (res != NO_ERROR) {
1739 ALOGE("(%s): substream attach failed. res(%d)", __FUNCTION__, res);
1740 return 1;
1741 }
1742 ALOGV("(%s): m_numRegisteredStream = %d", __FUNCTION__, parentStream->m_numRegisteredStream);
1743 ALOGV("(%s): Enabling Jpeg", __FUNCTION__);
13d8c7b4
SK		 1744 return 0;
1745 }
74d78ebe 1746 else if (format == HAL_PIXEL_FORMAT_YCrCb_420_SP || format == HAL_PIXEL_FORMAT_YV12) {
5506cebf
SK		 1747 *stream_id = STREAM_ID_PRVCB;
1748
1749 subParameters = &m_subStreams[STREAM_ID_PRVCB];
1750 memset(subParameters, 0, sizeof(substream_parameters_t));
1751
74d78ebe
SK		 1752 parentStream = (StreamThread*)(m_streamThreads[0].get());
1753 if (!parentStream) {
74d78ebe
SK		 1754 return 1;
1755 }
74d78ebe
SK		 1756
1757 *format_actual = format;
1758 *usage = GRALLOC_USAGE_SW_WRITE_OFTEN;
5506cebf
SK		 1759 *max_buffers = 6;
1760
1761 subParameters->type = SUBSTREAM_TYPE_PRVCB;
1762 subParameters->width = width;
1763 subParameters->height = height;
1764 subParameters->format = *format_actual;
1765 subParameters->svcPlanes = NUM_PLANES(*format_actual);
1766 subParameters->streamOps = stream_ops;
1767 subParameters->usage = *usage;
1768 subParameters->numOwnSvcBuffers = *max_buffers;
1769 subParameters->numSvcBufsInHal = 0;
1770 subParameters->needBufferInit = false;
1771 subParameters->minUndequedBuffer = 2;
1772
1773 if (format == HAL_PIXEL_FORMAT_YCrCb_420_SP) {
1774 subParameters->internalFormat = HAL_PIXEL_FORMAT_EXYNOS_YCrCb_420_SP;
1775 subParameters->internalPlanes = NUM_PLANES(HAL_PIXEL_FORMAT_EXYNOS_YCrCb_420_SP);
1776 }
1777 else {
1778 subParameters->internalFormat = HAL_PIXEL_FORMAT_EXYNOS_YV12;
1779 subParameters->internalPlanes = NUM_PLANES(HAL_PIXEL_FORMAT_EXYNOS_YV12);
1780 }
74d78ebe 1781
5506cebf
SK		 1782 res = parentStream->attachSubStream(STREAM_ID_PRVCB, 20);
1783 if (res != NO_ERROR) {
1784 ALOGE("(%s): substream attach failed. res(%d)", __FUNCTION__, res);
1785 return 1;
74d78ebe 1786 }
5506cebf
SK		 1787 ALOGV("(%s): m_numRegisteredStream = %d", __FUNCTION__, parentStream->m_numRegisteredStream);
1788 ALOGV("(%s): Enabling previewcb", __FUNCTION__);
74d78ebe
SK		 1789 return 0;
1790 }
ed4ad5fe 1791 ALOGE("(%s): Unsupported Pixel Format", __FUNCTION__);
5506cebf 1792 return 1;
c15a6b00
JS		 1793}
1794
13d8c7b4
SK		 1795int ExynosCameraHWInterface2::registerStreamBuffers(uint32_t stream_id,
1796 int num_buffers, buffer_handle_t *registeringBuffers)
c15a6b00 1797{
13d8c7b4
SK		 1798 int i,j;
1799 void *virtAddr[3];
5506cebf
SK		 1800 int plane_index = 0;
1801 StreamThread * targetStream;
13d8c7b4
SK		 1802 stream_parameters_t *targetStreamParms;
1803 node_info_t *currentNode;
1804
c15a6b00
JS		 1805 struct v4l2_buffer v4l2_buf;
1806 struct v4l2_plane planes[VIDEO_MAX_PLANES];
13d8c7b4 1807
ed4ad5fe 1808 ALOGD("(%s): stream_id(%d), num_buff(%d), handle(%x) ", __FUNCTION__,
13d8c7b4
SK		 1809 stream_id, num_buffers, (uint32_t)registeringBuffers);
1810
5506cebf
SK		 1811 if (stream_id == STREAM_ID_PREVIEW && m_streamThreads[0].get()) {
1812 targetStream = m_streamThreads[0].get();
13d8c7b4 1813 targetStreamParms = &(m_streamThreads[0]->m_parameters);
5c88d1f2 1814
13d8c7b4 1815 }
5506cebf
SK		 1816 else if (stream_id == STREAM_ID_JPEG || stream_id == STREAM_ID_RECORD || stream_id == STREAM_ID_PRVCB) {
1817 substream_parameters_t *targetParms;
1818 targetParms = &m_subStreams[stream_id];
9dd63e1f 1819
5506cebf 1820 targetParms->numSvcBuffers = num_buffers;
9dd63e1f 1821
5506cebf
SK		 1822 for (i = 0 ; i < targetParms->numSvcBuffers ; i++) {
1823 ALOGV("(%s): registering substream(%d) Buffers[%d] (%x) ", __FUNCTION__,
1824 i, stream_id, (uint32_t)(registeringBuffers[i]));
9dd63e1f
SK		 1825 if (m_grallocHal) {
1826 if (m_grallocHal->lock(m_grallocHal, registeringBuffers[i],
5506cebf
SK		 1827 targetParms->usage, 0, 0,
1828 targetParms->width, targetParms->height, virtAddr) != 0) {
9dd63e1f
SK		 1829 ALOGE("ERR(%s): could not obtain gralloc buffer", __FUNCTION__);
1830 }
1831 else {
1832 ExynosBuffer currentBuf;
1833 const private_handle_t *priv_handle = reinterpret_cast<const private_handle_t *>(registeringBuffers[i]);
5506cebf
SK		 1834 if (targetParms->svcPlanes == 1) {
1835 currentBuf.fd.extFd[0] = priv_handle->fd;
1836 currentBuf.size.extS[0] = priv_handle->size;
1837 currentBuf.size.extS[1] = 0;
1838 currentBuf.size.extS[2] = 0;
1839 } else if (targetParms->svcPlanes == 2) {
1840 currentBuf.fd.extFd[0] = priv_handle->fd;
1841 currentBuf.fd.extFd[1] = priv_handle->fd1;
1842
1843 } else if (targetParms->svcPlanes == 3) {
1844 currentBuf.fd.extFd[0] = priv_handle->fd;
1845 currentBuf.fd.extFd[1] = priv_handle->fd1;
1846 currentBuf.fd.extFd[2] = priv_handle->fd2;
1847 }
1848 for (plane_index = 0 ; plane_index < targetParms->svcPlanes ; plane_index++) {
9dd63e1f 1849 currentBuf.virt.extP[plane_index] = (char *)virtAddr[plane_index];
0d220b42 1850 CAM_LOGV("DEBUG(%s): plane(%d): fd(%d) addr(%x) size(%d)",
804236a7 1851 __FUNCTION__, plane_index, currentBuf.fd.extFd[plane_index],
5506cebf 1852 (unsigned int)currentBuf.virt.extP[plane_index], currentBuf.size.extS[plane_index]);
9dd63e1f 1853 }
5506cebf
SK		 1854 targetParms->svcBufStatus[i] = ON_SERVICE;
1855 targetParms->svcBuffers[i] = currentBuf;
1856 targetParms->svcBufHandle[i] = registeringBuffers[i];
9dd63e1f
SK		 1857 }
1858 }
1859 }
5506cebf 1860 targetParms->needBufferInit = true;
9dd63e1f
SK		 1861 return 0;
1862 }
5506cebf
SK		 1863 else if (stream_id == STREAM_ID_ZSL && m_streamThreads[1].get()) {
1864 targetStream = m_streamThreads[1].get();
1865 targetStreamParms = &(m_streamThreads[1]->m_parameters);
74d78ebe 1866 }
13d8c7b4 1867 else {
ed4ad5fe 1868 ALOGE("(%s): unregistered stream id (%d)", __FUNCTION__, stream_id);
be494d19 1869 return 1;
13d8c7b4 1870 }
c15a6b00 1871
5506cebf 1872 if (targetStream->streamType == STREAM_TYPE_DIRECT) {
13d8c7b4
SK		 1873 if (num_buffers < targetStreamParms->numHwBuffers) {
1874 ALOGE("ERR(%s) registering insufficient num of buffers (%d) < (%d)",
1875 __FUNCTION__, num_buffers, targetStreamParms->numHwBuffers);
be494d19 1876 return 1;
13d8c7b4
SK		 1877 }
1878 }
0d220b42 1879 CAM_LOGV("DEBUG(%s): format(%x) width(%d), height(%d) svcPlanes(%d)",
5506cebf
SK		 1880 __FUNCTION__, targetStreamParms->format, targetStreamParms->width,
1881 targetStreamParms->height, targetStreamParms->planes);
13d8c7b4 1882 targetStreamParms->numSvcBuffers = num_buffers;
5506cebf
SK		 1883 currentNode = targetStreamParms->node;
1884 currentNode->width = targetStreamParms->width;
1885 currentNode->height = targetStreamParms->height;
1886 currentNode->format = HAL_PIXEL_FORMAT_2_V4L2_PIX(targetStreamParms->format);
1887 currentNode->planes = targetStreamParms->planes;
13d8c7b4 1888 currentNode->buffers = targetStreamParms->numHwBuffers;
5506cebf
SK		 1889 cam_int_s_input(currentNode, m_camera_info.sensor_id);
1890 cam_int_s_fmt(currentNode);
1891 cam_int_reqbufs(currentNode);
1892 for (i = 0 ; i < targetStreamParms->numSvcBuffers ; i++) {
13d8c7b4
SK		 1893 ALOGV("DEBUG(%s): registering Stream Buffers[%d] (%x) ", __FUNCTION__,
1894 i, (uint32_t)(registeringBuffers[i]));
13d8c7b4
SK		 1895 v4l2_buf.m.planes = planes;
1896 v4l2_buf.type = currentNode->type;
1897 v4l2_buf.memory = currentNode->memory;
1898 v4l2_buf.index = i;
1899 v4l2_buf.length = currentNode->planes;
c15a6b00 1900
13d8c7b4 1901 ExynosBuffer currentBuf;
feb7df4c 1902 ExynosBuffer metaBuf;
13d8c7b4
SK		 1903 const private_handle_t *priv_handle = reinterpret_cast<const private_handle_t *>(registeringBuffers[i]);
1904
1905 m_getAlignedYUVSize(currentNode->format,
1906 currentNode->width, currentNode->height, &currentBuf);
24231221 1907
37e122d5
SK		 1908 ALOGV("DEBUG(%s): ion_size(%d), stride(%d), ", __FUNCTION__, priv_handle->size, priv_handle->stride);
1909 if (currentNode->planes == 1) {
74d78ebe
SK		 1910 v4l2_buf.m.planes[0].m.fd = priv_handle->fd;
1911 currentBuf.fd.extFd[0] = priv_handle->fd;
37e122d5
SK		 1912 currentBuf.size.extS[0] = priv_handle->size;
1913 currentBuf.size.extS[1] = 0;
1914 currentBuf.size.extS[2] = 0;
74d78ebe
SK		 1915 } else if (currentNode->planes == 2) {
1916 v4l2_buf.m.planes[0].m.fd = priv_handle->fd;
1917 v4l2_buf.m.planes[1].m.fd = priv_handle->fd1;
1918 currentBuf.fd.extFd[0] = priv_handle->fd;
1919 currentBuf.fd.extFd[1] = priv_handle->fd1;
1920
1921 } else if (currentNode->planes == 3) {
1922 v4l2_buf.m.planes[0].m.fd = priv_handle->fd;
1923 v4l2_buf.m.planes[2].m.fd = priv_handle->fd1;
1924 v4l2_buf.m.planes[1].m.fd = priv_handle->fd2;
1925 currentBuf.fd.extFd[0] = priv_handle->fd;
1926 currentBuf.fd.extFd[2] = priv_handle->fd1;
1927 currentBuf.fd.extFd[1] = priv_handle->fd2;
37e122d5 1928 }
0d220b42 1929
5506cebf 1930 for (plane_index = 0 ; plane_index < (int)v4l2_buf.length ; plane_index++) {
0d220b42 1931 currentBuf.virt.extP[plane_index] = (char *)ion_map(currentBuf.fd.extFd[plane_index], currentBuf.size.extS[plane_index], 0);
13d8c7b4 1932 v4l2_buf.m.planes[plane_index].length = currentBuf.size.extS[plane_index];
0d220b42 1933 CAM_LOGV("DEBUG(%s): plane(%d): fd(%d) addr(%x), length(%d)",
13d8c7b4
SK		 1934 __FUNCTION__, plane_index, v4l2_buf.m.planes[plane_index].m.fd,
1935 (unsigned int)currentBuf.virt.extP[plane_index],
1936 v4l2_buf.m.planes[plane_index].length);
1937 }
c15a6b00 1938
5506cebf 1939 if (i < currentNode->buffers) {
feb7df4c
SK		 1940
1941
1942#ifdef ENABLE_FRAME_SYNC
5506cebf
SK		 1943 /* add plane for metadata*/
1944 metaBuf.size.extS[0] = 4*1024;
1945 allocCameraMemory(m_ionCameraClient , &metaBuf, 1, 1<<0);
feb7df4c 1946
5506cebf
SK		 1947 v4l2_buf.length += targetStreamParms->metaPlanes;
1948 v4l2_buf.m.planes[v4l2_buf.length-1].m.fd = metaBuf.fd.extFd[0];
1949 v4l2_buf.m.planes[v4l2_buf.length-1].length = metaBuf.size.extS[0];
feb7df4c 1950
5506cebf 1951 ALOGV("Qbuf metaBuf: fd(%d), length(%d) plane(%d)", metaBuf.fd.extFd[0], metaBuf.size.extS[0], v4l2_buf.length);
feb7df4c 1952#endif
5506cebf
SK		 1953 if (exynos_v4l2_qbuf(currentNode->fd, &v4l2_buf) < 0) {
1954 ALOGE("ERR(%s): stream id(%d) exynos_v4l2_qbuf() fail fd(%d)",
1955 __FUNCTION__, stream_id, currentNode->fd);
13d8c7b4 1956 }
5506cebf
SK		 1957 ALOGV("DEBUG(%s): stream id(%d) exynos_v4l2_qbuf() success fd(%d)",
1958 __FUNCTION__, stream_id, currentNode->fd);
1959 targetStreamParms->svcBufStatus[i] = REQUIRES_DQ_FROM_SVC;
13d8c7b4 1960 }
5506cebf 1961 else {
13d8c7b4 1962 targetStreamParms->svcBufStatus[i] = ON_SERVICE;
c15a6b00 1963 }
5506cebf 1964
13d8c7b4 1965 targetStreamParms->svcBuffers[i] = currentBuf;
feb7df4c 1966 targetStreamParms->metaBuffers[i] = metaBuf;
13d8c7b4
SK		 1967 targetStreamParms->svcBufHandle[i] = registeringBuffers[i];
1968 }
15fd8231 1969
5506cebf
SK		 1970 ALOGV("DEBUG(%s): calling streamon stream id = %d", __FUNCTION__, stream_id);
1971 cam_int_streamon(targetStreamParms->node);
ad37861e 1972 ALOGV("DEBUG(%s): calling streamon END", __FUNCTION__);
5506cebf 1973 currentNode->status = true;
13d8c7b4 1974 ALOGV("DEBUG(%s): END registerStreamBuffers", __FUNCTION__);
ad37861e 1975
c15a6b00
JS		 1976 return 0;
1977}
1978
1979int ExynosCameraHWInterface2::releaseStream(uint32_t stream_id)
1980{
13d8c7b4 1981 StreamThread *targetStream;
5506cebf 1982 status_t res = NO_ERROR;
ed4ad5fe 1983 ALOGD("(%s): stream_id(%d)", __FUNCTION__, stream_id);
5506cebf 1984 bool releasingScpMain = false;
13d8c7b4 1985
5506cebf 1986 if (stream_id == STREAM_ID_PREVIEW) {
13d8c7b4 1987 targetStream = (StreamThread*)(m_streamThreads[0].get());
5506cebf
SK		 1988 targetStream->m_numRegisteredStream--;
1989 ALOGV("(%s): m_numRegisteredStream = %d", __FUNCTION__, targetStream->m_numRegisteredStream);
1990 releasingScpMain = true;
0d220b42
C		 1991 for (int i = 0; i < targetStream->m_parameters.numSvcBuffers; i++) {
1992 for (int j = 0; j < targetStream->m_parameters.planes; j++) {
1993 ion_unmap(targetStream->m_parameters.svcBuffers[i].virt.extP[j],
1994 targetStream->m_parameters.svcBuffers[i].size.extS[j]);
1995 CAM_LOGD("DBG(%s) ummap stream buffer[%d], plane(%d), fd %d vaddr %x", __FUNCTION__, i, j,
1996 targetStream->m_parameters.svcBuffers[i].fd.extFd[j], targetStream->m_parameters.svcBuffers[i].virt.extP[j]);
1997 }
1998 }
5506cebf 1999 } else if (stream_id == STREAM_ID_JPEG) {
13d8c7b4 2000 targetStream = (StreamThread*)(m_streamThreads[1].get());
5506cebf
SK		 2001 memset(&m_subStreams[stream_id], 0, sizeof(substream_parameters_t));
2002 if (m_resizeBuf.size.s != 0) {
2003 freeCameraMemory(&m_resizeBuf, 1);
2004 }
2005 if (targetStream)
2006 res = targetStream->detachSubStream(stream_id);
2007 if (res != NO_ERROR) {
2008 ALOGE("(%s): substream detach failed. res(%d)", __FUNCTION__, res);
2009 return 1;
2010 }
2011 ALOGV("(%s): m_numRegisteredStream = %d", __FUNCTION__, targetStream->m_numRegisteredStream);
74d78ebe 2012 return 0;
5506cebf
SK		 2013 } else if (stream_id == STREAM_ID_RECORD) {
2014 targetStream = (StreamThread*)(m_streamThreads[0].get());
2015 memset(&m_subStreams[stream_id], 0, sizeof(substream_parameters_t));
2016 if (targetStream)
2017 res = targetStream->detachSubStream(stream_id);
2018 else
2019 return 0;
2020 } else if (stream_id == STREAM_ID_PRVCB) {
2021 targetStream = (StreamThread*)(m_streamThreads[0].get());
2022 if (m_resizeBuf.size.s != 0) {
2023 freeCameraMemory(&m_previewCbBuf, m_subStreams[stream_id].internalPlanes);
2024 }
2025 memset(&m_subStreams[stream_id], 0, sizeof(substream_parameters_t));
2026 if (targetStream)
2027 res = targetStream->detachSubStream(stream_id);
2028 else
2029 return 0;
2030 } else if (stream_id == STREAM_ID_ZSL) {
2031 targetStream = (StreamThread*)(m_streamThreads[1].get());
2032 targetStream->m_numRegisteredStream--;
2033 ALOGV("(%s): m_numRegisteredStream = %d", __FUNCTION__, targetStream->m_numRegisteredStream);
2034 } else {
13d8c7b4 2035 ALOGE("ERR:(%s): wrong stream id (%d)", __FUNCTION__, stream_id);
be494d19 2036 return 1;
13d8c7b4
SK		 2037 }
2038
5506cebf
SK		 2039 if (m_streamThreads[1]->m_numRegisteredStream == 0 && m_streamThreads[1]->m_activated) {
2040 ALOGV("(%s): deactivating stream thread 1 ", __FUNCTION__);
2041 targetStream = (StreamThread*)(m_streamThreads[1].get());
2042 targetStream->m_releasing = true;
2043 do {
2044 CAM_LOGD("stream thread release %d", __LINE__);
2045 targetStream->release();
2046 usleep(33000);
2047 } while (targetStream->m_releasing);
2048 }
2049
2050 if (releasingScpMain || (m_streamThreads[0]->m_numRegisteredStream == 0 && m_streamThreads[0]->m_activated)) {
2051 ALOGV("(%s): deactivating stream thread 0", __FUNCTION__);
2052 targetStream = (StreamThread*)(m_streamThreads[0].get());
2053 targetStream->m_releasing = true;
2054 do {
ed4ad5fe 2055 ALOGD("(%s): Waiting for (indirect) stream thread release - line(%d)", __FUNCTION__, __LINE__);
5506cebf
SK		 2056 targetStream->release();
2057 usleep(33000);
2058 } while (targetStream->m_releasing);
2059 targetStream->SetSignal(SIGNAL_THREAD_TERMINATE);
2060
2061 if (targetStream != NULL) {
2062 while (targetStream->IsTerminated())
2063 {
ed4ad5fe 2064 ALOGD("(%s): Waiting for (indirect) stream thread termination", __FUNCTION__);
5506cebf
SK		 2065 usleep(10000);
2066 }
2067 m_streamThreads[0] = NULL;
2068 }
2069
2070 if (m_sensorThread != NULL) {
2071 m_sensorThread->release();
2072 while (!m_sensorThread->IsTerminated()){
ed4ad5fe 2073 ALOGD("(%s): Waiting for (indirect) sensor thread termination", __FUNCTION__);
5506cebf
SK		 2074 usleep(10000);
2075 }
2076 }
2077 else {
2078 ALOGE("+++++++ sensor thread is NULL %d", __LINE__);
2079 }
2080
2081 if (m_camera_info.capture.status == true) {
2082 if (cam_int_streamoff(&(m_camera_info.capture)) < 0) {
2083 ALOGE("ERR(%s): capture stream off fail", __FUNCTION__);
2084 } else {
2085 m_camera_info.capture.status = false;
2086 }
2087 ALOGV("(%s): calling capture streamoff done", __FUNCTION__);
2088 if (m_streamThreads[1]->streamType == STREAM_TYPE_INDIRECT) {
2089 m_camera_info.capture.buffers = 0;
2090 ALOGV("DEBUG(%s): capture calling reqbuf 0 ", __FUNCTION__);
2091 cam_int_reqbufs(&(m_camera_info.capture));
2092 ALOGV("DEBUG(%s): capture calling reqbuf 0 done", __FUNCTION__);
2093 }
2094 }
2095 m_isIspStarted = false;
2096 }
2097 ALOGV("(%s): END", __FUNCTION__);
c15a6b00
JS		 2098 return 0;
2099}
2100
2101int ExynosCameraHWInterface2::allocateReprocessStream(
13d8c7b4
SK		 2102 uint32_t width, uint32_t height, uint32_t format,
2103 const camera2_stream_in_ops_t *reprocess_stream_ops,
c15a6b00
JS		 2104 uint32_t *stream_id, uint32_t *consumer_usage, uint32_t *max_buffers)
2105{
13d8c7b4 2106 ALOGV("DEBUG(%s):", __FUNCTION__);
c15a6b00
JS		 2107 return 0;
2108}
2109
5506cebf
SK		 2110int ExynosCameraHWInterface2::allocateReprocessStreamFromStream(
2111 uint32_t output_stream_id,
2112 const camera2_stream_in_ops_t *reprocess_stream_ops,
2113 // outputs
2114 uint32_t *stream_id)
2115{
ed4ad5fe 2116 ALOGD("(%s): output_stream_id(%d)", __FUNCTION__, output_stream_id);
5506cebf
SK		 2117 *stream_id = STREAM_ID_JPEG_REPROCESS;
2118
2119 m_reprocessStreamId = *stream_id;
2120 m_reprocessOps = reprocess_stream_ops;
2121 m_reprocessOutputStreamId = output_stream_id;
2122 return 0;
2123}
2124
c15a6b00
JS		 2125int ExynosCameraHWInterface2::releaseReprocessStream(uint32_t stream_id)
2126{
ed4ad5fe 2127 ALOGD("(%s): stream_id(%d)", __FUNCTION__, stream_id);
5506cebf
SK		 2128 if (stream_id == STREAM_ID_JPEG_REPROCESS) {
2129 m_reprocessStreamId = 0;
2130 m_reprocessOps = NULL;
2131 m_reprocessOutputStreamId = 0;
2132 return 0;
2133 }
2134 return 1;
c15a6b00
JS		 2135}
2136
2137int ExynosCameraHWInterface2::triggerAction(uint32_t trigger_id, int ext1, int ext2)
2138{
0f26b20f
SK		 2139 ALOGV("DEBUG(%s): id(%x), %d, %d", __FUNCTION__, trigger_id, ext1, ext2);
2140
2141 switch (trigger_id) {
2142 case CAMERA2_TRIGGER_AUTOFOCUS:
2143 ALOGV("DEBUG(%s):TRIGGER_AUTOFOCUS id(%d)", __FUNCTION__, ext1);
8e2c2fdb 2144 OnAfTriggerStart(ext1);
0f26b20f
SK		 2145 break;
2146
2147 case CAMERA2_TRIGGER_CANCEL_AUTOFOCUS:
2148 ALOGV("DEBUG(%s):CANCEL_AUTOFOCUS id(%d)", __FUNCTION__, ext1);
2149 OnAfCancel(ext1);
2150 break;
e117f756
YJ		 2151 case CAMERA2_TRIGGER_PRECAPTURE_METERING:
2152 ALOGV("DEBUG(%s):CAMERA2_TRIGGER_PRECAPTURE_METERING id(%d)", __FUNCTION__, ext1);
2153 OnPrecaptureMeteringTriggerStart(ext1);
2154 break;
0f26b20f
SK		 2155 default:
2156 break;
2157 }
c15a6b00
JS		 2158 return 0;
2159}
2160
2161int ExynosCameraHWInterface2::setNotifyCallback(camera2_notify_callback notify_cb, void *user)
2162{
0f26b20f 2163 ALOGV("DEBUG(%s): cb_addr(%x)", __FUNCTION__, (unsigned int)notify_cb);
c15a6b00
JS		 2164 m_notifyCb = notify_cb;
2165 m_callbackCookie = user;
2166 return 0;
2167}
2168
2169int ExynosCameraHWInterface2::getMetadataVendorTagOps(vendor_tag_query_ops_t **ops)
2170{
13d8c7b4 2171 ALOGV("DEBUG(%s):", __FUNCTION__);
c15a6b00
JS		 2172 return 0;
2173}
2174
2175int ExynosCameraHWInterface2::dump(int fd)
2176{
13d8c7b4 2177 ALOGV("DEBUG(%s):", __FUNCTION__);
c15a6b00
JS		 2178 return 0;
2179}
2180
13d8c7b4
SK		 2181void ExynosCameraHWInterface2::m_getAlignedYUVSize(int colorFormat, int w, int h, ExynosBuffer *buf)
2182{
2183 switch (colorFormat) {
2184 // 1p
2185 case V4L2_PIX_FMT_RGB565 :
2186 case V4L2_PIX_FMT_YUYV :
2187 case V4L2_PIX_FMT_UYVY :
2188 case V4L2_PIX_FMT_VYUY :
2189 case V4L2_PIX_FMT_YVYU :
2190 buf->size.extS[0] = FRAME_SIZE(V4L2_PIX_2_HAL_PIXEL_FORMAT(colorFormat), w, h);
2191 buf->size.extS[1] = 0;
2192 buf->size.extS[2] = 0;
2193 break;
2194 // 2p
2195 case V4L2_PIX_FMT_NV12 :
2196 case V4L2_PIX_FMT_NV12T :
2197 case V4L2_PIX_FMT_NV21 :
2198 buf->size.extS[0] = ALIGN(w, 16) * ALIGN(h, 16);
2199 buf->size.extS[1] = ALIGN(w/2, 16) * ALIGN(h/2, 16);
2200 buf->size.extS[2] = 0;
2201 break;
2202 case V4L2_PIX_FMT_NV12M :
2203 case V4L2_PIX_FMT_NV12MT_16X16 :
9dd63e1f 2204 case V4L2_PIX_FMT_NV21M:
13d8c7b4
SK		 2205 buf->size.extS[0] = ALIGN(w, 16) * ALIGN(h, 16);
2206 buf->size.extS[1] = ALIGN(buf->size.extS[0] / 2, 256);
2207 buf->size.extS[2] = 0;
2208 break;
2209 case V4L2_PIX_FMT_NV16 :
2210 case V4L2_PIX_FMT_NV61 :
2211 buf->size.extS[0] = ALIGN(w, 16) * ALIGN(h, 16);
2212 buf->size.extS[1] = ALIGN(w, 16) * ALIGN(h, 16);
2213 buf->size.extS[2] = 0;
2214 break;
2215 // 3p
2216 case V4L2_PIX_FMT_YUV420 :
2217 case V4L2_PIX_FMT_YVU420 :
2218 buf->size.extS[0] = (w * h);
2219 buf->size.extS[1] = (w * h) >> 2;
2220 buf->size.extS[2] = (w * h) >> 2;
2221 break;
2222 case V4L2_PIX_FMT_YUV420M:
2223 case V4L2_PIX_FMT_YVU420M :
2224 case V4L2_PIX_FMT_YUV422P :
0d220b42 2225 buf->size.extS[0] = ALIGN(w, 16) * ALIGN(h, 16);
13d8c7b4
SK		 2226 buf->size.extS[1] = ALIGN(w/2, 16) * ALIGN(h/2, 8);
2227 buf->size.extS[2] = ALIGN(w/2, 16) * ALIGN(h/2, 8);
2228 break;
2229 default:
2230 ALOGE("ERR(%s):unmatched colorFormat(%d)", __FUNCTION__, colorFormat);
2231 return;
2232 break;
2233 }
2234}
c15a6b00 2235
13d8c7b4
SK		 2236bool ExynosCameraHWInterface2::m_getRatioSize(int src_w, int src_h,
2237 int dst_w, int dst_h,
2238 int *crop_x, int *crop_y,
2239 int *crop_w, int *crop_h,
2240 int zoom)
c15a6b00 2241{
13d8c7b4
SK		 2242 *crop_w = src_w;
2243 *crop_h = src_h;
2244
2245 if ( src_w != dst_w
2246 || src_h != dst_h) {
2247 float src_ratio = 1.0f;
2248 float dst_ratio = 1.0f;
2249
2250 // ex : 1024 / 768
2251 src_ratio = (float)src_w / (float)src_h;
2252
2253 // ex : 352 / 288
2254 dst_ratio = (float)dst_w / (float)dst_h;
2255
2256 if (dst_w * dst_h < src_w * src_h) {
2257 if (dst_ratio <= src_ratio) {
2258 // shrink w
2259 *crop_w = src_h * dst_ratio;
2260 *crop_h = src_h;
2261 } else {
2262 // shrink h
2263 *crop_w = src_w;
2264 *crop_h = src_w / dst_ratio;
c15a6b00 2265 }
13d8c7b4
SK		 2266 } else {
2267 if (dst_ratio <= src_ratio) {
2268 // shrink w
2269 *crop_w = src_h * dst_ratio;
2270 *crop_h = src_h;
2271 } else {
2272 // shrink h
2273 *crop_w = src_w;
2274 *crop_h = src_w / dst_ratio;
c15a6b00
JS		 2275 }
2276 }
c15a6b00
JS		 2277 }
2278
13d8c7b4
SK		 2279 if (zoom != 0) {
2280 float zoomLevel = ((float)zoom + 10.0) / 10.0;
2281 *crop_w = (int)((float)*crop_w / zoomLevel);
2282 *crop_h = (int)((float)*crop_h / zoomLevel);
2283 }
2284
2285 #define CAMERA_CROP_WIDTH_RESTRAIN_NUM (0x2)
2286 unsigned int w_align = (*crop_w & (CAMERA_CROP_WIDTH_RESTRAIN_NUM - 1));
2287 if (w_align != 0) {
2288 if ( (CAMERA_CROP_WIDTH_RESTRAIN_NUM >> 1) <= w_align
2289 && *crop_w + (CAMERA_CROP_WIDTH_RESTRAIN_NUM - w_align) <= dst_w) {
2290 *crop_w += (CAMERA_CROP_WIDTH_RESTRAIN_NUM - w_align);
2291 }
2292 else
2293 *crop_w -= w_align;
2294 }
2295
2296 #define CAMERA_CROP_HEIGHT_RESTRAIN_NUM (0x2)
2297 unsigned int h_align = (*crop_h & (CAMERA_CROP_HEIGHT_RESTRAIN_NUM - 1));
2298 if (h_align != 0) {
2299 if ( (CAMERA_CROP_HEIGHT_RESTRAIN_NUM >> 1) <= h_align
2300 && *crop_h + (CAMERA_CROP_HEIGHT_RESTRAIN_NUM - h_align) <= dst_h) {
2301 *crop_h += (CAMERA_CROP_HEIGHT_RESTRAIN_NUM - h_align);
2302 }
2303 else
2304 *crop_h -= h_align;
2305 }
2306
2307 *crop_x = (src_w - *crop_w) >> 1;
2308 *crop_y = (src_h - *crop_h) >> 1;
2309
2310 if (*crop_x & (CAMERA_CROP_WIDTH_RESTRAIN_NUM >> 1))
2311 *crop_x -= 1;
2312
2313 if (*crop_y & (CAMERA_CROP_HEIGHT_RESTRAIN_NUM >> 1))
2314 *crop_y -= 1;
2315
2316 return true;
2317}
2318
9dd63e1f 2319BayerBufManager::BayerBufManager()
13d8c7b4 2320{
9dd63e1f
SK		 2321 ALOGV("DEBUG(%s): ", __FUNCTION__);
2322 for (int i = 0; i < NUM_BAYER_BUFFERS ; i++) {
2323 entries[i].status = BAYER_ON_HAL_EMPTY;
2324 entries[i].reqFrameCnt = 0;
13d8c7b4 2325 }
9dd63e1f
SK		 2326 sensorEnqueueHead = 0;
2327 sensorDequeueHead = 0;
2328 ispEnqueueHead = 0;
2329 ispDequeueHead = 0;
2330 numOnSensor = 0;
2331 numOnIsp = 0;
2332 numOnHalFilled = 0;
2333 numOnHalEmpty = NUM_BAYER_BUFFERS;
13d8c7b4
SK		 2334}
2335
15fd8231
SK		 2336BayerBufManager::~BayerBufManager()
2337{
2338 ALOGV("%s", __FUNCTION__);
2339}
2340
9dd63e1f 2341int BayerBufManager::GetIndexForSensorEnqueue()
13d8c7b4 2342{
9dd63e1f
SK		 2343 int ret = 0;
2344 if (numOnHalEmpty == 0)
2345 ret = -1;
2346 else
2347 ret = sensorEnqueueHead;
2348 ALOGV("DEBUG(%s): returning (%d)", __FUNCTION__, ret);
2349 return ret;
13d8c7b4
SK		 2350}
2351
9dd63e1f 2352int BayerBufManager::MarkSensorEnqueue(int index)
13d8c7b4 2353{
9dd63e1f
SK		 2354 ALOGV("DEBUG(%s) : BayerIndex[%d] ", __FUNCTION__, index);
2355
2356 // sanity check
2357 if (index != sensorEnqueueHead) {
2358 ALOGV("DEBUG(%s) : Abnormal BayerIndex[%d] - expected[%d]", __FUNCTION__, index, sensorEnqueueHead);
2359 return -1;
2360 }
2361 if (entries[index].status != BAYER_ON_HAL_EMPTY) {
2362 ALOGV("DEBUG(%s) : Abnormal status in BayerIndex[%d] = (%d) expected (%d)", __FUNCTION__,
2363 index, entries[index].status, BAYER_ON_HAL_EMPTY);
2364 return -1;
13d8c7b4 2365 }
13d8c7b4 2366
9dd63e1f
SK		 2367 entries[index].status = BAYER_ON_SENSOR;
2368 entries[index].reqFrameCnt = 0;
2369 numOnHalEmpty--;
2370 numOnSensor++;
2371 sensorEnqueueHead = GetNextIndex(index);
2372 ALOGV("DEBUG(%s) END: HAL-e(%d) HAL-f(%d) Sensor(%d) ISP(%d) ",
2373 __FUNCTION__, numOnHalEmpty, numOnHalFilled, numOnSensor, numOnIsp);
2374 return 0;
2375}
13d8c7b4 2376
9dd63e1f 2377int BayerBufManager::MarkSensorDequeue(int index, int reqFrameCnt, nsecs_t *timeStamp)
13d8c7b4 2378{
9dd63e1f
SK		 2379 ALOGV("DEBUG(%s) : BayerIndex[%d] reqFrameCnt(%d)", __FUNCTION__, index, reqFrameCnt);
2380
9dd63e1f 2381 if (entries[index].status != BAYER_ON_SENSOR) {
ad37861e 2382 ALOGE("DEBUG(%s) : Abnormal status in BayerIndex[%d] = (%d) expected (%d)", __FUNCTION__,
9dd63e1f
SK		 2383 index, entries[index].status, BAYER_ON_SENSOR);
2384 return -1;
13d8c7b4 2385 }
13d8c7b4 2386
9dd63e1f 2387 entries[index].status = BAYER_ON_HAL_FILLED;
9dd63e1f
SK		 2388 numOnHalFilled++;
2389 numOnSensor--;
ad37861e 2390
9dd63e1f
SK		 2391 return 0;
2392}
2393
2394int BayerBufManager::GetIndexForIspEnqueue(int *reqFrameCnt)
2395{
2396 int ret = 0;
2397 if (numOnHalFilled == 0)
2398 ret = -1;
2399 else {
2400 *reqFrameCnt = entries[ispEnqueueHead].reqFrameCnt;
2401 ret = ispEnqueueHead;
13d8c7b4 2402 }
9dd63e1f 2403 ALOGV("DEBUG(%s): returning BayerIndex[%d]", __FUNCTION__, ret);
13d8c7b4
SK		 2404 return ret;
2405}
2406
9dd63e1f
SK		 2407int BayerBufManager::GetIndexForIspDequeue(int *reqFrameCnt)
2408{
2409 int ret = 0;
2410 if (numOnIsp == 0)
2411 ret = -1;
2412 else {
2413 *reqFrameCnt = entries[ispDequeueHead].reqFrameCnt;
2414 ret = ispDequeueHead;
2415 }
2416 ALOGV("DEBUG(%s): returning BayerIndex[%d]", __FUNCTION__, ret);
2417 return ret;
2418}
13d8c7b4 2419
9dd63e1f 2420int BayerBufManager::MarkIspEnqueue(int index)
13d8c7b4 2421{
9dd63e1f
SK		 2422 ALOGV("DEBUG(%s) : BayerIndex[%d] ", __FUNCTION__, index);
2423
2424 // sanity check
2425 if (index != ispEnqueueHead) {
2426 ALOGV("DEBUG(%s) : Abnormal BayerIndex[%d] - expected[%d]", __FUNCTION__, index, ispEnqueueHead);
13d8c7b4
SK		 2427 return -1;
2428 }
9dd63e1f
SK		 2429 if (entries[index].status != BAYER_ON_HAL_FILLED) {
2430 ALOGV("DEBUG(%s) : Abnormal status in BayerIndex[%d] = (%d) expected (%d)", __FUNCTION__,
2431 index, entries[index].status, BAYER_ON_HAL_FILLED);
2432 return -1;
13d8c7b4
SK		 2433 }
2434
9dd63e1f
SK		 2435 entries[index].status = BAYER_ON_ISP;
2436 numOnHalFilled--;
2437 numOnIsp++;
2438 ispEnqueueHead = GetNextIndex(index);
2439 ALOGV("DEBUG(%s) END: HAL-e(%d) HAL-f(%d) Sensor(%d) ISP(%d) ",
2440 __FUNCTION__, numOnHalEmpty, numOnHalFilled, numOnSensor, numOnIsp);
2441 return 0;
2442}
2443
2444int BayerBufManager::MarkIspDequeue(int index)
2445{
2446 ALOGV("DEBUG(%s) : BayerIndex[%d]", __FUNCTION__, index);
2447
2448 // sanity check
2449 if (index != ispDequeueHead) {
2450 ALOGV("DEBUG(%s) : Abnormal BayerIndex[%d] - expected[%d]", __FUNCTION__, index, ispDequeueHead);
2451 return -1;
13d8c7b4 2452 }
9dd63e1f
SK		 2453 if (entries[index].status != BAYER_ON_ISP) {
2454 ALOGV("DEBUG(%s) : Abnormal status in BayerIndex[%d] = (%d) expected (%d)", __FUNCTION__,
2455 index, entries[index].status, BAYER_ON_ISP);
13d8c7b4
SK		 2456 return -1;
2457 }
2458
9dd63e1f
SK		 2459 entries[index].status = BAYER_ON_HAL_EMPTY;
2460 entries[index].reqFrameCnt = 0;
2461 numOnHalEmpty++;
2462 numOnIsp--;
2463 ispDequeueHead = GetNextIndex(index);
2464 ALOGV("DEBUG(%s) END: HAL-e(%d) HAL-f(%d) Sensor(%d) ISP(%d) ",
2465 __FUNCTION__, numOnHalEmpty, numOnHalFilled, numOnSensor, numOnIsp);
2466 return 0;
2467}
13d8c7b4 2468
9dd63e1f
SK		 2469int BayerBufManager::GetNumOnSensor()
2470{
2471 return numOnSensor;
13d8c7b4
SK		 2472}
2473
9dd63e1f 2474int BayerBufManager::GetNumOnHalFilled()
13d8c7b4 2475{
9dd63e1f
SK		 2476 return numOnHalFilled;
2477}
2478
2479int BayerBufManager::GetNumOnIsp()
2480{
2481 return numOnIsp;
2482}
2483
2484int BayerBufManager::GetNextIndex(int index)
2485{
2486 index++;
2487 if (index >= NUM_BAYER_BUFFERS)
2488 index = 0;
2489
2490 return index;
2491}
2492
2493void ExynosCameraHWInterface2::m_mainThreadFunc(SignalDrivenThread * self)
2494{
2495 camera_metadata_t *currentRequest = NULL;
2496 camera_metadata_t *currentFrame = NULL;
2497 size_t numEntries = 0;
2498 size_t frameSize = 0;
2499 camera_metadata_t * preparedFrame = NULL;
13d8c7b4
SK		 2500 camera_metadata_t *deregisteredRequest = NULL;
2501 uint32_t currentSignal = self->GetProcessingSignal();
2502 MainThread * selfThread = ((MainThread*)self);
2503 int res = 0;
2504
ad37861e
SK		 2505 int ret;
2506
13d8c7b4
SK		 2507 ALOGV("DEBUG(%s): m_mainThreadFunc (%x)", __FUNCTION__, currentSignal);
2508
2509 if (currentSignal & SIGNAL_THREAD_RELEASE) {
2510 ALOGV("DEBUG(%s): processing SIGNAL_THREAD_RELEASE", __FUNCTION__);
2511
2512 ALOGV("DEBUG(%s): processing SIGNAL_THREAD_RELEASE DONE", __FUNCTION__);
2513 selfThread->SetSignal(SIGNAL_THREAD_TERMINATE);
2514 return;
2515 }
2516
2517 if (currentSignal & SIGNAL_MAIN_REQ_Q_NOT_EMPTY) {
2518 ALOGV("DEBUG(%s): MainThread processing SIGNAL_MAIN_REQ_Q_NOT_EMPTY", __FUNCTION__);
ad37861e 2519 if (m_requestManager->IsRequestQueueFull()==false) {
13d8c7b4
SK		 2520 m_requestQueueOps->dequeue_request(m_requestQueueOps, &currentRequest);
2521 if (NULL == currentRequest) {
ad37861e 2522 ALOGE("DEBUG(%s)(0x%x): dequeue_request returned NULL ", __FUNCTION__, currentSignal);
13d8c7b4 2523 m_isRequestQueueNull = true;
5c88d1f2
C		 2524#ifdef VDIS_ENABLE
2525 if (m_requestManager->IsVdisEnable())
2526 m_vdisBubbleCnt = 1;
2527#endif
13d8c7b4
SK		 2528 }
2529 else {
2530 m_requestManager->RegisterRequest(currentRequest);
2531
2532 m_numOfRemainingReqInSvc = m_requestQueueOps->request_count(m_requestQueueOps);
2533 ALOGV("DEBUG(%s): remaining req cnt (%d)", __FUNCTION__, m_numOfRemainingReqInSvc);
ad37861e 2534 if (m_requestManager->IsRequestQueueFull()==false)
13d8c7b4 2535 selfThread->SetSignal(SIGNAL_MAIN_REQ_Q_NOT_EMPTY); // dequeue repeatedly
9dd63e1f 2536
13d8c7b4
SK		 2537 m_sensorThread->SetSignal(SIGNAL_SENSOR_START_REQ_PROCESSING);
2538 }
c15a6b00
JS		 2539 }
2540 else {
13d8c7b4
SK		 2541 m_isRequestQueuePending = true;
2542 }
2543 }
2544
2545 if (currentSignal & SIGNAL_MAIN_STREAM_OUTPUT_DONE) {
2546 ALOGV("DEBUG(%s): MainThread processing SIGNAL_MAIN_STREAM_OUTPUT_DONE", __FUNCTION__);
2547 /*while (1)*/ {
0f26b20f 2548 ret = m_requestManager->PrepareFrame(&numEntries, &frameSize, &preparedFrame, GetAfStateForService());
ad37861e 2549 if (ret == false)
0d220b42 2550 CAM_LOGE("ERR(%s): PrepareFrame ret = %d", __FUNCTION__, ret);
ad37861e 2551
13d8c7b4 2552 m_requestManager->DeregisterRequest(&deregisteredRequest);
ad37861e
SK		 2553
2554 ret = m_requestQueueOps->free_request(m_requestQueueOps, deregisteredRequest);
2555 if (ret < 0)
0d220b42 2556 CAM_LOGE("ERR(%s): free_request ret = %d", __FUNCTION__, ret);
ad37861e
SK		 2557
2558 ret = m_frameQueueOps->dequeue_frame(m_frameQueueOps, numEntries, frameSize, &currentFrame);
2559 if (ret < 0)
0d220b42 2560 CAM_LOGE("ERR(%s): dequeue_frame ret = %d", __FUNCTION__, ret);
ad37861e 2561
13d8c7b4 2562 if (currentFrame==NULL) {
ad37861e 2563 ALOGV("DBG(%s): frame dequeue returned NULL",__FUNCTION__ );
13d8c7b4
SK		 2564 }
2565 else {
daa1fcd6 2566 ALOGV("DEBUG(%s): frame dequeue done. numEntries(%d) frameSize(%d)",__FUNCTION__ , numEntries, frameSize);
13d8c7b4
SK		 2567 }
2568 res = append_camera_metadata(currentFrame, preparedFrame);
2569 if (res==0) {
2570 ALOGV("DEBUG(%s): frame metadata append success",__FUNCTION__);
2571 m_frameQueueOps->enqueue_frame(m_frameQueueOps, currentFrame);
ad37861e
SK		 2572 }
2573 else {
2574 ALOGE("ERR(%s): frame metadata append fail (%d)",__FUNCTION__, res);
2575 }
2576 }
2577 if (!m_isRequestQueueNull) {
2578 selfThread->SetSignal(SIGNAL_MAIN_REQ_Q_NOT_EMPTY);
2579 }
c15a6b00 2580
ad37861e
SK		 2581 if (getInProgressCount()>0) {
2582 ALOGV("DEBUG(%s): STREAM_OUTPUT_DONE and signalling REQ_PROCESSING",__FUNCTION__);
2583 m_sensorThread->SetSignal(SIGNAL_SENSOR_START_REQ_PROCESSING);
2584 }
c15a6b00 2585 }
ad37861e
SK		 2586 ALOGV("DEBUG(%s): MainThread Exit", __FUNCTION__);
2587 return;
2588}
c15a6b00 2589
ad37861e
SK		 2590void ExynosCameraHWInterface2::m_sensorThreadInitialize(SignalDrivenThread * self)
2591{
2592 ALOGV("DEBUG(%s): ", __FUNCTION__ );
2593 /* will add */
13d8c7b4
SK		 2594 return;
2595}
2596
2597
13d8c7b4
SK		 2598void ExynosCameraHWInterface2::DumpInfoWithShot(struct camera2_shot_ext * shot_ext)
2599{
ad37861e
SK		 2600 ALOGD("#### common Section");
2601 ALOGD("#### magic(%x) ",
13d8c7b4 2602 shot_ext->shot.magicNumber);
ad37861e
SK		 2603 ALOGD("#### ctl Section");
2604 ALOGD("#### meta(%d) aper(%f) exp(%lld) duration(%lld) ISO(%d) AWB(%d)",
13d8c7b4 2605 shot_ext->shot.ctl.request.metadataMode,
b56dcc00 2606 shot_ext->shot.ctl.lens.aperture,
13d8c7b4
SK		 2607 shot_ext->shot.ctl.sensor.exposureTime,
2608 shot_ext->shot.ctl.sensor.frameDuration,
b56dcc00
SK		 2609 shot_ext->shot.ctl.sensor.sensitivity,
2610 shot_ext->shot.ctl.aa.awbMode);
13d8c7b4 2611
5506cebf 2612 ALOGD("#### OutputStream Sensor(%d) SCP(%d) SCC(%d) streams(%x)",
9dd63e1f 2613 shot_ext->request_sensor, shot_ext->request_scp, shot_ext->request_scc,
5506cebf 2614 shot_ext->shot.ctl.request.outputStreams[0]);
13d8c7b4 2615
ad37861e
SK		 2616 ALOGD("#### DM Section");
2617 ALOGD("#### meta(%d) aper(%f) exp(%lld) duration(%lld) ISO(%d) timestamp(%lld) AWB(%d) cnt(%d)",
13d8c7b4 2618 shot_ext->shot.dm.request.metadataMode,
b56dcc00 2619 shot_ext->shot.dm.lens.aperture,
13d8c7b4
SK		 2620 shot_ext->shot.dm.sensor.exposureTime,
2621 shot_ext->shot.dm.sensor.frameDuration,
2622 shot_ext->shot.dm.sensor.sensitivity,
b56dcc00
SK		 2623 shot_ext->shot.dm.sensor.timeStamp,
2624 shot_ext->shot.dm.aa.awbMode,
2625 shot_ext->shot.dm.request.frameCount );
13d8c7b4
SK		 2626}
2627
e117f756 2628void ExynosCameraHWInterface2::m_preCaptureSetter(struct camera2_shot_ext * shot_ext)
6f19b6cf 2629{
e117f756
YJ		 2630 // Flash
2631 switch (m_ctlInfo.flash.m_flashCnt) {
2632 case IS_FLASH_STATE_ON:
2633 CAM_LOGV("(%s): [Flash] Flash ON for Capture", __FUNCTION__);
2634 if (m_ctlInfo.flash.i_flashMode == AA_AEMODE_ON_ALWAYS_FLASH) {
2635 shot_ext->shot.ctl.aa.aeflashMode = AA_FLASHMODE_ON_ALWAYS;
2636 m_ctlInfo.flash.m_flashTimeOut = 5;
2637 } else
2638 shot_ext->shot.ctl.aa.aeflashMode = AA_FLASHMODE_ON;
2639 m_ctlInfo.flash.m_flashCnt = IS_FLASH_STATE_ON_WAIT;
9a710a45 2640 break;
e117f756 2641 case IS_FLASH_STATE_ON_WAIT:
6f19b6cf 2642 break;
e117f756
YJ		 2643 case IS_FLASH_STATE_ON_DONE:
2644 if (!m_ctlInfo.flash.m_afFlashDoneFlg)
2645 // auto transition at pre-capture trigger
2646 m_ctlInfo.flash.m_flashCnt = IS_FLASH_STATE_AUTO_AE_AWB_LOCK;
6f19b6cf 2647 break;
e117f756
YJ		 2648 case IS_FLASH_STATE_AUTO_AE_AWB_LOCK:
2649 CAM_LOGV("(%s): [Flash] IS_FLASH_AF_AUTO_AE_AWB_LOCK", __FUNCTION__);
2650 shot_ext->shot.ctl.aa.aeflashMode = AA_FLASHMODE_AUTO;
2651 //shot_ext->shot.ctl.aa.aeMode = AA_AEMODE_LOCKED;
2652 shot_ext->shot.ctl.aa.awbMode = AA_AWBMODE_LOCKED;
2653 m_ctlInfo.flash.m_flashCnt = IS_FLASH_STATE_AE_AWB_LOCK_WAIT;
2654 break;
2655 case IS_FLASH_STATE_AE_AWB_LOCK_WAIT:
2656 case IS_FLASH_STATE_AUTO_WAIT:
2657 shot_ext->shot.ctl.aa.aeMode =(enum aa_aemode)0;
2658 shot_ext->shot.ctl.aa.awbMode = (enum aa_awbmode)0;
2659 break;
2660 case IS_FLASH_STATE_AUTO_DONE:
2661 CAM_LOGV("(%s): [Flash] IS_FLASH_AF_AUTO DONE", __FUNCTION__);
2662 break;
2663 case IS_FLASH_STATE_AUTO_OFF:
2664 CAM_LOGV("(%s): [Flash] IS_FLASH_AF_AUTO Clear", __FUNCTION__);
2665 shot_ext->shot.ctl.aa.aeflashMode = AA_FLASHMODE_OFF;
2666 m_ctlInfo.flash.m_afFlashDoneFlg = false;
2667 m_ctlInfo.flash.m_flashEnableFlg = false;
2668 break;
2669 case IS_FLASH_STATE_CAPTURE:
2670 CAM_LOGV("(%s): [Flash] IS_FLASH_CAPTURE", __FUNCTION__);
2671 m_ctlInfo.flash.m_flashTimeOut = FLASH_STABLE_WAIT_TIMEOUT;
2672 shot_ext->shot.ctl.aa.aeflashMode = AA_FLASHMODE_CAPTURE;
2673 shot_ext->request_scc = 0;
2674 shot_ext->request_scp = 0;
2675 m_ctlInfo.flash.m_flashCnt = IS_FLASH_STATE_CAPTURE_WAIT; // auto transition
2676 break;
2677 case IS_FLASH_STATE_CAPTURE_WAIT:
2678 shot_ext->request_scc = 0;
2679 shot_ext->request_scp = 0;
2680 break;
2681 case IS_FLASH_STATE_CAPTURE_JPEG:
2682 CAM_LOGE("(%s): [Flash] Flash Capture (%d)!!!!!", __FUNCTION__, (FLASH_STABLE_WAIT_TIMEOUT -m_ctlInfo.flash.m_flashTimeOut));
2683 shot_ext->request_scc = 1;
2684 shot_ext->request_scp = 1;
2685 m_ctlInfo.flash.m_flashCnt = IS_FLASH_STATE_CAPTURE_END; // auto transition
2686 break;
2687 case IS_FLASH_STATE_CAPTURE_END:
2688 CAM_LOGV("(%s): [Flash] Flash Capture END", __FUNCTION__);
2689 shot_ext->shot.ctl.aa.aeflashMode = AA_FLASHMODE_OFF;
2690 shot_ext->request_scc = 0;
2691 shot_ext->request_scp = 0;
2692 m_ctlInfo.flash.m_flashEnableFlg = false;
2693 m_ctlInfo.flash.m_flashCnt = 0;
2694 m_ctlInfo.flash.m_afFlashDoneFlg= false;
2695 break;
2696 default:
2697 ALOGE("(%s): [Flash] flash state error!! (%d)", __FUNCTION__, m_ctlInfo.flash.m_flashCnt);
6f19b6cf
YJ		 2698 }
2699}
2700
e117f756 2701void ExynosCameraHWInterface2::m_preCaptureListenerSensor(struct camera2_shot_ext * shot_ext)
6f19b6cf 2702{
e117f756
YJ		 2703 // Flash
2704 switch (m_ctlInfo.flash.m_flashCnt) {
2705 case IS_FLASH_STATE_AUTO_WAIT:
2706 if (m_ctlInfo.flash.m_flashDecisionResult) {
2707 if (shot_ext->shot.dm.flash.flashMode == CAM2_FLASH_MODE_OFF) {
2708 m_ctlInfo.flash.m_flashCnt = IS_FLASH_STATE_AUTO_DONE;
2709 CAM_LOGV("(%s): [Flash] Lis : AUTO -> OFF (%d)", __FUNCTION__, shot_ext->shot.dm.flash.flashMode);
9257e29e 2710 } else {
e117f756 2711 CAM_LOGV("(%s): [Flash] Waiting : AUTO -> OFF", __FUNCTION__);
9257e29e 2712 }
e117f756
YJ		 2713 } else {
2714 //If flash isn't activated at flash auto mode, skip flash auto control
2715 m_ctlInfo.flash.m_flashCnt = IS_FLASH_STATE_AUTO_DONE;
2716 CAM_LOGV("(%s): [Flash] Skip : AUTO -> OFF", __FUNCTION__);
9257e29e 2717 }
e117f756 2718 break;
9257e29e 2719 }
9257e29e
YJ		 2720}
2721
e117f756 2722void ExynosCameraHWInterface2::m_preCaptureListenerISP(struct camera2_shot_ext * shot_ext)
9257e29e 2723{
e117f756
YJ		 2724 // Flash
2725 switch (m_ctlInfo.flash.m_flashCnt) {
2726 case IS_FLASH_STATE_ON_WAIT:
2727 if (shot_ext->shot.dm.flash.decision > 0) {
2728 // store decision result to skip capture sequenece
2729 CAM_LOGV("(%s): [Flash] IS_FLASH_ON, decision - %d", __FUNCTION__, shot_ext->shot.dm.flash.decision);
2730 if (shot_ext->shot.dm.flash.decision == 2)
2731 m_ctlInfo.flash.m_flashDecisionResult = false;
2732 else
2733 m_ctlInfo.flash.m_flashDecisionResult = true;
2734 m_ctlInfo.flash.m_flashCnt = IS_FLASH_STATE_ON_DONE;
2735 } else {
2736 if (m_ctlInfo.flash.m_flashTimeOut == 0) {
2737 CAM_LOGV("(%s): [Flash] Timeout IS_FLASH_ON, decision is false setting", __FUNCTION__);
2738 m_ctlInfo.flash.m_flashCnt = IS_FLASH_STATE_ON_DONE;
2739 m_ctlInfo.flash.m_flashDecisionResult = false;
caea49e6 2740 } else {
e117f756 2741 m_ctlInfo.flash.m_flashTimeOut--;
6f19b6cf 2742 }
6f19b6cf 2743 }
e117f756
YJ		 2744 break;
2745 case IS_FLASH_STATE_AE_AWB_LOCK_WAIT:
2746 if (shot_ext->shot.dm.aa.awbMode == AA_AWBMODE_LOCKED) {
2747 CAM_LOGV("(%s): [Flash] FLASH_AUTO_AE_AWB_LOCK_WAIT - %d", __FUNCTION__, shot_ext->shot.dm.aa.awbMode);
2748 m_ctlInfo.flash.m_flashCnt = IS_FLASH_STATE_AUTO_WAIT;
2749 } else {
2750 CAM_LOGV("(%s): [Flash] Waiting : AA_AWBMODE_LOCKED", __FUNCTION__);
2751 }
2752 break;
2753 case IS_FLASH_STATE_CAPTURE_WAIT:
2754 if (m_ctlInfo.flash.m_flashDecisionResult) {
2755 if (shot_ext->shot.dm.flash.firingStable) {
2756 m_ctlInfo.flash.m_flashCnt = IS_FLASH_STATE_CAPTURE_JPEG;
6f19b6cf 2757 } else {
9257e29e 2758 if (m_ctlInfo.flash.m_flashTimeOut == 0) {
e117f756
YJ		 2759 ALOGE("(%s): [Flash] Wait firingStable time-out!!", __FUNCTION__);
2760 m_ctlInfo.flash.m_flashCnt = IS_FLASH_STATE_CAPTURE_JPEG;
9257e29e 2761 } else {
e117f756 2762 ALOGV("(%s): [Flash] Wait firingStable - %d", __FUNCTION__, m_ctlInfo.flash.m_flashTimeOut);
9257e29e
YJ		 2763 m_ctlInfo.flash.m_flashTimeOut--;
2764 }
6f19b6cf 2765 }
e117f756
YJ		 2766 } else {
2767 m_ctlInfo.flash.m_flashCnt = IS_FLASH_STATE_CAPTURE_JPEG;
6f19b6cf 2768 }
e117f756 2769 break;
6f19b6cf 2770 }
6f19b6cf
YJ		 2771}
2772
13d8c7b4
SK		 2773void ExynosCameraHWInterface2::m_sensorThreadFunc(SignalDrivenThread * self)
2774{
2775 uint32_t currentSignal = self->GetProcessingSignal();
2776 SensorThread * selfThread = ((SensorThread*)self);
2777 int index;
ad37861e 2778 int index_isp;
13d8c7b4
SK		 2779 status_t res;
2780 nsecs_t frameTime;
2781 int bayersOnSensor = 0, bayersOnIsp = 0;
ad37861e
SK		 2782 int j = 0;
2783 bool isCapture = false;
13d8c7b4
SK		 2784 ALOGV("DEBUG(%s): m_sensorThreadFunc (%x)", __FUNCTION__, currentSignal);
2785
2786 if (currentSignal & SIGNAL_THREAD_RELEASE) {
2c872806 2787 CAM_LOGD("(%s): ENTER processing SIGNAL_THREAD_RELEASE", __FUNCTION__);
13d8c7b4 2788
9dd63e1f 2789 ALOGV("(%s): calling sensor streamoff", __FUNCTION__);
13d8c7b4 2790 cam_int_streamoff(&(m_camera_info.sensor));
9dd63e1f 2791 ALOGV("(%s): calling sensor streamoff done", __FUNCTION__);
b5237e6b
SK		 2792
2793 m_camera_info.sensor.buffers = 0;
2794 ALOGV("DEBUG(%s): sensor calling reqbuf 0 ", __FUNCTION__);
2795 cam_int_reqbufs(&(m_camera_info.sensor));
2796 ALOGV("DEBUG(%s): sensor calling reqbuf 0 done", __FUNCTION__);
5506cebf 2797 m_camera_info.sensor.status = false;
ad37861e 2798
9dd63e1f
SK		 2799 ALOGV("(%s): calling ISP streamoff", __FUNCTION__);
2800 isp_int_streamoff(&(m_camera_info.isp));
2801 ALOGV("(%s): calling ISP streamoff done", __FUNCTION__);
ad37861e 2802
b5237e6b
SK		 2803 m_camera_info.isp.buffers = 0;
2804 ALOGV("DEBUG(%s): isp calling reqbuf 0 ", __FUNCTION__);
2805 cam_int_reqbufs(&(m_camera_info.isp));
2806 ALOGV("DEBUG(%s): isp calling reqbuf 0 done", __FUNCTION__);
2807
13d8c7b4 2808 exynos_v4l2_s_ctrl(m_camera_info.sensor.fd, V4L2_CID_IS_S_STREAM, IS_DISABLE_STREAM);
13d8c7b4 2809
52f54308 2810 m_requestManager->releaseSensorQ();
2adfa429 2811 m_requestManager->ResetEntry();
ad37861e 2812 ALOGV("(%s): EXIT processing SIGNAL_THREAD_RELEASE", __FUNCTION__);
13d8c7b4
SK		 2813 selfThread->SetSignal(SIGNAL_THREAD_TERMINATE);
2814 return;
2815 }
2816
2817 if (currentSignal & SIGNAL_SENSOR_START_REQ_PROCESSING)
2818 {
2819 ALOGV("DEBUG(%s): SensorThread processing SIGNAL_SENSOR_START_REQ_PROCESSING", __FUNCTION__);
9dd63e1f 2820 int targetStreamIndex = 0, i=0;
ad37861e 2821 int matchedFrameCnt = -1, processingReqIndex;
13d8c7b4 2822 struct camera2_shot_ext *shot_ext;
ad37861e 2823 struct camera2_shot_ext *shot_ext_capture;
0f26b20f
SK		 2824 bool triggered = false;
2825 int afMode;
9dd63e1f 2826
ad37861e 2827 /* dqbuf from sensor */
5506cebf 2828 ALOGV("Sensor DQbuf start");
13d8c7b4 2829 index = cam_int_dqbuf(&(m_camera_info.sensor));
52f54308
SK		 2830 m_requestManager->pushSensorQ(index);
2831 ALOGV("Sensor DQbuf done(%d)", index);
9dd63e1f 2832 shot_ext = (struct camera2_shot_ext *)(m_camera_info.sensor.buffer[index].virt.extP[1]);
ad37861e 2833
a15b4e3f
SK		 2834 if (m_nightCaptureCnt != 0) {
2835 matchedFrameCnt = m_nightCaptureFrameCnt;
e117f756 2836 } else if (m_ctlInfo.flash.m_flashCnt >= IS_FLASH_STATE_CAPTURE) {
9a710a45 2837 matchedFrameCnt = m_ctlInfo.flash.m_flashFrameCount;
caea49e6 2838 ALOGV("Skip frame, request is fixed at %d", matchedFrameCnt);
6f19b6cf 2839 } else {
a15b4e3f
SK		 2840 matchedFrameCnt = m_requestManager->FindFrameCnt(shot_ext);
2841 }
ad37861e 2842
5c88d1f2
C		 2843#ifdef VDIS_ENABLE
2844 if (matchedFrameCnt == -1 && m_vdisBubbleCnt > 0) {
2845 matchedFrameCnt = m_vdisDupFrame;
2846 }
2847#endif
2848
a07cbd98 2849 if (matchedFrameCnt != -1) {
5c88d1f2
C		 2850#ifdef VDIS_ENABLE
2851 if (m_vdisBubbleCnt == 0) {
2852 frameTime = systemTime();
2853 m_requestManager->RegisterTimestamp(matchedFrameCnt, &frameTime);
2854 m_requestManager->UpdateIspParameters(shot_ext, matchedFrameCnt, &m_ctlInfo);
2855 }
2856#else
ef6f83ca
SK		 2857 frameTime = systemTime();
2858 m_requestManager->RegisterTimestamp(matchedFrameCnt, &frameTime);
53f62ad9 2859 m_requestManager->UpdateIspParameters(shot_ext, matchedFrameCnt, &m_ctlInfo);
5c88d1f2 2860#endif
9a710a45 2861
8e2c2fdb
SK		 2862 if (m_afModeWaitingCnt != 0) {
2863 ALOGV("### Af Trigger pulled, waiting for mode change cnt(%d) ", m_afModeWaitingCnt);
2864 m_afModeWaitingCnt --;
2865 if (m_afModeWaitingCnt == 1) {
cd13bb78 2866 m_afModeWaitingCnt = 0;
8e2c2fdb
SK		 2867 OnAfTrigger(m_afPendingTriggerId);
2868 }
2869 }
308291de 2870 m_zoomRatio = (float)m_camera2->getSensorW() / (float)shot_ext->shot.ctl.scaler.cropRegion[2];
e4657e32
SK		 2871 float zoomLeft, zoomTop, zoomWidth, zoomHeight;
2872 int crop_x = 0, crop_y = 0, crop_w = 0, crop_h = 0;
2873
2874 m_getRatioSize(m_camera2->getSensorW(), m_camera2->getSensorH(),
5506cebf 2875 m_streamThreads[0]->m_parameters.width, m_streamThreads[0]->m_parameters.height,
e4657e32
SK		 2876 &crop_x, &crop_y,
2877 &crop_w, &crop_h,
2878 0);
2879
5506cebf 2880 if (m_streamThreads[0]->m_parameters.width >= m_streamThreads[0]->m_parameters.height) {
308291de 2881 zoomWidth = m_camera2->getSensorW() / m_zoomRatio;
e4657e32 2882 zoomHeight = zoomWidth *
5506cebf 2883 m_streamThreads[0]->m_parameters.height / m_streamThreads[0]->m_parameters.width;
e4657e32 2884 } else {
308291de 2885 zoomHeight = m_camera2->getSensorH() / m_zoomRatio;
e4657e32 2886 zoomWidth = zoomHeight *
5506cebf 2887 m_streamThreads[0]->m_parameters.width / m_streamThreads[0]->m_parameters.height;
e4657e32
SK		 2888 }
2889 zoomLeft = (crop_w - zoomWidth) / 2;
2890 zoomTop = (crop_h - zoomHeight) / 2;
2891
2892 int32_t new_cropRegion[3] = { zoomLeft, zoomTop, zoomWidth };
2893
5506cebf 2894 if (new_cropRegion[0] * 2 + new_cropRegion[2] > (int32_t)m_camera2->getSensorW())
308291de 2895 new_cropRegion[2]--;
5506cebf 2896 else if (new_cropRegion[0] * 2 + new_cropRegion[2] < (int32_t)m_camera2->getSensorW())
308291de
C		 2897 new_cropRegion[2]++;
2898
e4657e32
SK		 2899 shot_ext->shot.ctl.scaler.cropRegion[0] = new_cropRegion[0];
2900 shot_ext->shot.ctl.scaler.cropRegion[1] = new_cropRegion[1];
2901 shot_ext->shot.ctl.scaler.cropRegion[2] = new_cropRegion[2];
0f26b20f 2902 if (m_IsAfModeUpdateRequired) {
ed4ad5fe 2903 ALOGD("### AF Mode change(Mode %d) ", m_afMode);
0f26b20f
SK		 2904 shot_ext->shot.ctl.aa.afMode = m_afMode;
2905 if (m_afMode == AA_AFMODE_CONTINUOUS_VIDEO || m_afMode == AA_AFMODE_CONTINUOUS_PICTURE) {
ed4ad5fe 2906 ALOGD("### With Automatic triger for continuous modes");
0f26b20f
SK		 2907 m_afState = HAL_AFSTATE_STARTED;
2908 shot_ext->shot.ctl.aa.afTrigger = 1;
2909 triggered = true;
2910 }
2911 m_IsAfModeUpdateRequired = false;
311d52eb
YJ		 2912 // support inifinity focus mode
2913 if ((m_afMode == AA_AFMODE_OFF) && ( shot_ext->shot.ctl.lens.focusDistance == 0)) {
2914 shot_ext->shot.ctl.aa.afMode = AA_AFMODE_INFINITY;
2915 shot_ext->shot.ctl.aa.afTrigger = 1;
2916 triggered = true;
2917 }
0f26b20f
SK		 2918 if (m_afMode2 != NO_CHANGE) {
2919 enum aa_afmode tempAfMode = m_afMode2;
2920 m_afMode2 = NO_CHANGE;
2921 SetAfMode(tempAfMode);
2922 }
2923 }
2924 else {
2925 shot_ext->shot.ctl.aa.afMode = NO_CHANGE;
2926 }
2927 if (m_IsAfTriggerRequired) {
e117f756
YJ		 2928 if (m_ctlInfo.flash.m_flashEnableFlg && m_ctlInfo.flash.m_afFlashDoneFlg) {
2929 if (m_ctlInfo.flash.m_flashCnt == IS_FLASH_STATE_ON_DONE) {
6f19b6cf
YJ		 2930 // Flash is enabled and start AF
2931 if (m_afState == HAL_AFSTATE_SCANNING) {
ed4ad5fe 2932 ALOGD("(%s): restarting trigger ", __FUNCTION__);
6f19b6cf
YJ		 2933 } else {
2934 if (m_afState != HAL_AFSTATE_NEEDS_COMMAND)
ed4ad5fe 2935 ALOGD("(%s): wrong trigger state %d", __FUNCTION__, m_afState);
6f19b6cf
YJ		 2936 else
2937 m_afState = HAL_AFSTATE_STARTED;
2938 }
ed4ad5fe 2939 ALOGD("### AF Triggering with mode (%d)", m_afMode);
6f19b6cf
YJ		 2940 shot_ext->shot.ctl.aa.afTrigger = 1;
2941 shot_ext->shot.ctl.aa.afMode = m_afMode;
2942 m_IsAfTriggerRequired = false;
2943 }
2944 } else {
ed4ad5fe 2945 ALOGD("### AF Triggering with mode (%d)", m_afMode);
6f19b6cf 2946 if (m_afState == HAL_AFSTATE_SCANNING) {
ed4ad5fe 2947 ALOGD("(%s): restarting trigger ", __FUNCTION__);
6f19b6cf
YJ		 2948 } else {
2949 if (m_afState != HAL_AFSTATE_NEEDS_COMMAND)
ed4ad5fe 2950 ALOGD("(%s): wrong trigger state %d", __FUNCTION__, m_afState);
6f19b6cf
YJ		 2951 else
2952 m_afState = HAL_AFSTATE_STARTED;
2953 }
2954 shot_ext->shot.ctl.aa.afTrigger = 1;
2955 shot_ext->shot.ctl.aa.afMode = m_afMode;
2956 m_IsAfTriggerRequired = false;
36c106c9 2957 }
0f26b20f
SK		 2958 }
2959 else {
8e2c2fdb 2960 shot_ext->shot.ctl.aa.afTrigger = 0;
0f26b20f 2961 }
5506cebf
SK		 2962
2963 if (m_wideAspect) {
2964 shot_ext->setfile = ISS_SUB_SCENARIO_VIDEO;
2965 shot_ext->shot.ctl.aa.aeTargetFpsRange[0] = 30;
15fd8231 2966 shot_ext->shot.ctl.aa.aeTargetFpsRange[1] = 30;
5506cebf
SK		 2967 } else {
2968 shot_ext->setfile = ISS_SUB_SCENARIO_STILL;
15fd8231 2969 }
0f26b20f
SK		 2970 if (triggered)
2971 shot_ext->shot.ctl.aa.afTrigger = 1;
2972
2973 // TODO : check collision with AFMode Update
2974 if (m_IsAfLockRequired) {
2975 shot_ext->shot.ctl.aa.afMode = AA_AFMODE_OFF;
2976 m_IsAfLockRequired = false;
2977 }
4ed2f103 2978 ALOGV("### Isp Qbuf start(%d) count (%d), SCP(%d) SCC(%d) DIS(%d) shot_size(%d)",
ad37861e
SK		 2979 index,
2980 shot_ext->shot.ctl.request.frameCount,
2981 shot_ext->request_scp,
2982 shot_ext->request_scc,
2983 shot_ext->dis_bypass, sizeof(camera2_shot));
8e2c2fdb
SK		 2984 if (0 == shot_ext->shot.ctl.aa.afRegions[0] && 0 == shot_ext->shot.ctl.aa.afRegions[1]
2985 && 0 == shot_ext->shot.ctl.aa.afRegions[2] && 0 == shot_ext->shot.ctl.aa.afRegions[3]) {
2986 ALOGV("(%s): AF region resetting", __FUNCTION__);
2987 lastAfRegion[0] = 0;
2988 lastAfRegion[1] = 0;
2989 lastAfRegion[2] = 0;
2990 lastAfRegion[3] = 0;
2991 }
2992 else {
2993 if (!(lastAfRegion[0] == shot_ext->shot.ctl.aa.afRegions[0] && lastAfRegion[1] == shot_ext->shot.ctl.aa.afRegions[1]
2994 && lastAfRegion[2] == shot_ext->shot.ctl.aa.afRegions[2] && lastAfRegion[3] == shot_ext->shot.ctl.aa.afRegions[3])) {
caea49e6 2995 ALOGE("(%s): AF region changed : triggering", __FUNCTION__);
8e2c2fdb
SK		 2996 shot_ext->shot.ctl.aa.afTrigger = 1;
2997 shot_ext->shot.ctl.aa.afMode = m_afMode;
2998 m_afState = HAL_AFSTATE_STARTED;
2999 lastAfRegion[0] = shot_ext->shot.ctl.aa.afRegions[0];
3000 lastAfRegion[1] = shot_ext->shot.ctl.aa.afRegions[1];
3001 lastAfRegion[2] = shot_ext->shot.ctl.aa.afRegions[2];
3002 lastAfRegion[3] = shot_ext->shot.ctl.aa.afRegions[3];
3003 }
da7ca692
YJ		 3004 // clear region infos in case of CAF mode
3005 if (m_afMode == AA_AFMODE_CONTINUOUS_VIDEO || m_afMode == AA_AFMODE_CONTINUOUS_PICTURE) {
3006 shot_ext->shot.ctl.aa.afRegions[0] = lastAfRegion[0] = 0;
3007 shot_ext->shot.ctl.aa.afRegions[1] = lastAfRegion[1] = 0;
3008 shot_ext->shot.ctl.aa.afRegions[2] = lastAfRegion[2] = 0;
3009 shot_ext->shot.ctl.aa.afRegions[3] = lastAfRegion[3] = 0;
3010 }
8e2c2fdb 3011 }
6bf36b60
SK		 3012 if (shot_ext->shot.ctl.aa.sceneMode == AA_SCENE_MODE_NIGHT
3013 && shot_ext->shot.ctl.aa.aeMode == AA_AEMODE_LOCKED)
3014 shot_ext->shot.ctl.aa.aeMode = AA_AEMODE_ON;
a15b4e3f 3015 if (m_nightCaptureCnt == 0) {
5506cebf 3016 if (shot_ext->shot.ctl.aa.captureIntent == AA_CAPTURE_INTENT_STILL_CAPTURE
a15b4e3f
SK		 3017 && shot_ext->shot.ctl.aa.sceneMode == AA_SCENE_MODE_NIGHT) {
3018 shot_ext->shot.ctl.aa.sceneMode = AA_SCENE_MODE_NIGHT_CAPTURE;
6bf36b60 3019 shot_ext->shot.ctl.aa.aeTargetFpsRange[0] = 8;
a15b4e3f
SK		 3020 shot_ext->shot.ctl.aa.aeTargetFpsRange[1] = 30;
3021 m_nightCaptureCnt = 4;
3022 m_nightCaptureFrameCnt = matchedFrameCnt;
3023 shot_ext->request_scc = 0;
3024 }
3025 }
3026 else if (m_nightCaptureCnt == 1) {
3027 shot_ext->shot.ctl.aa.sceneMode = AA_SCENE_MODE_NIGHT_CAPTURE;
6bf36b60 3028 shot_ext->shot.ctl.aa.aeTargetFpsRange[0] = 8;
a15b4e3f
SK		 3029 shot_ext->shot.ctl.aa.aeTargetFpsRange[1] = 30;
3030 m_nightCaptureCnt--;
3031 shot_ext->request_scc = 1;
3032 }
6bf36b60
SK		 3033 else if (m_nightCaptureCnt == 2) {
3034 shot_ext->shot.ctl.aa.sceneMode = AA_SCENE_MODE_NIGHT_CAPTURE;
3035 shot_ext->shot.ctl.aa.aeTargetFpsRange[0] = 8;
3036 shot_ext->shot.ctl.aa.aeTargetFpsRange[1] = 30;
3037 m_nightCaptureCnt--;
3038 shot_ext->request_scc = 0;
3039 }
3040 else if (m_nightCaptureCnt == 3 || m_nightCaptureCnt == 4) {
a15b4e3f
SK		 3041 shot_ext->shot.ctl.aa.sceneMode = AA_SCENE_MODE_NIGHT_CAPTURE;
3042 shot_ext->shot.ctl.aa.aeTargetFpsRange[0] = 2;
3043 shot_ext->shot.ctl.aa.aeTargetFpsRange[1] = 30;
3044 m_nightCaptureCnt--;
3045 shot_ext->request_scc = 0;
3046 }
6f19b6cf
YJ		 3047
3048 // Flash mode
3049 // Keep and Skip request_scc = 1 at flash enable mode to operate flash sequence
e117f756
YJ		 3050 if ((m_ctlInfo.flash.i_flashMode >= AA_AEMODE_ON_AUTO_FLASH)
3051 && (shot_ext->shot.ctl.aa.captureIntent == AA_CAPTURE_INTENT_STILL_CAPTURE)
6f19b6cf 3052 && (m_cameraId == 0)) {
e117f756
YJ		 3053 if (!m_ctlInfo.flash.m_flashDecisionResult) {
3054 m_ctlInfo.flash.m_flashEnableFlg = false;
3055 m_ctlInfo.flash.m_afFlashDoneFlg = false;
3056 m_ctlInfo.flash.m_flashCnt = 0;
3057 } else if ((m_ctlInfo.flash.m_flashCnt == IS_FLASH_STATE_AUTO_DONE) || (m_ctlInfo.flash.m_flashCnt == IS_FLASH_STATE_AUTO_OFF)) {
6f19b6cf
YJ		 3058 ALOGE("(%s): [Flash] Flash capture start : skip request scc 1#####", __FUNCTION__);
3059 shot_ext->request_scc = 0;
9a710a45
YJ		 3060 m_ctlInfo.flash.m_flashFrameCount = matchedFrameCnt;
3061 m_ctlInfo.flash.m_flashEnableFlg = true;
e117f756
YJ		 3062 m_ctlInfo.flash.m_afFlashDoneFlg = false;
3063 m_ctlInfo.flash.m_flashCnt = IS_FLASH_STATE_CAPTURE;
caea49e6
YJ		 3064 }
3065 }
3066
3067 // TODO : set torch mode for video recording. need to find proper position.
3068 // m_wideAspect is will be changed to recording hint
3069 if ((shot_ext->shot.ctl.flash.flashMode == CAM2_FLASH_MODE_SINGLE) && m_wideAspect) {
3070 shot_ext->shot.ctl.flash.flashMode = CAM2_FLASH_MODE_TORCH;
3071 shot_ext->shot.ctl.flash.firingPower = 10;
3072 m_ctlInfo.flash.m_flashTorchMode = true;
3073 } else if (m_wideAspect){
3074 shot_ext->shot.ctl.flash.flashMode = CAM2_FLASH_MODE_OFF;
3075 shot_ext->shot.ctl.flash.firingPower = 0;
3076 m_ctlInfo.flash.m_flashTorchMode = false;
3077 } else {
3078 if (m_ctlInfo.flash.m_flashTorchMode) {
3079 shot_ext->shot.ctl.flash.flashMode = CAM2_FLASH_MODE_OFF;
3080 shot_ext->shot.ctl.flash.firingPower = 0;
3081 m_ctlInfo.flash.m_flashTorchMode = false;
3082 } else {
3083 shot_ext->shot.ctl.flash.flashMode = CAM2_FLASH_MODE_NOP;
6f19b6cf
YJ		 3084 }
3085 }
3086
e117f756
YJ		 3087 if (m_ctlInfo.flash.m_flashEnableFlg) {
3088 m_preCaptureListenerSensor(shot_ext);
3089 m_preCaptureSetter(shot_ext);
3090 }
3091
5506cebf
SK		 3092 if (shot_ext->isReprocessing) {
3093 ALOGE("(%s): Reprocess request ", __FUNCTION__);
3094 m_currentReprocessOutStreams = shot_ext->shot.ctl.request.outputStreams[0];
3095 shot_ext->request_scp = 0;
3096 shot_ext->request_scc = 0;
3097 m_reprocessingFrameCnt = shot_ext->shot.ctl.request.frameCount;
3098 memcpy(&m_jpegMetadata, &shot_ext->shot, sizeof(struct camera2_shot));
3099 m_streamThreads[1]->SetSignal(SIGNAL_STREAM_REPROCESSING_START);
3100 }
8e2c2fdb
SK		 3101 ALOGV("(%s): queued aa(%d) aemode(%d) awb(%d) afmode(%d) trigger(%d)", __FUNCTION__,
3102 (int)(shot_ext->shot.ctl.aa.mode), (int)(shot_ext->shot.ctl.aa.aeMode),
3103 (int)(shot_ext->shot.ctl.aa.awbMode), (int)(shot_ext->shot.ctl.aa.afMode),
3104 (int)(shot_ext->shot.ctl.aa.afTrigger));
7d0efb59 3105
5c88d1f2
C		 3106#ifdef VDIS_ENABLE
3107 if (m_vdisBubbleCnt > 0 && m_vdisDupFrame == matchedFrameCnt) {
3108 shot_ext->dis_bypass = 1;
3109 shot_ext->request_scp = 0;
3110 shot_ext->request_scc = 0;
3111 m_vdisBubbleCnt--;
3112 matchedFrameCnt = -1;
3113 } else {
3114 m_vdisDupFrame = matchedFrameCnt;
3115 }
3116#endif
3117
5506cebf 3118 uint32_t current_scp = shot_ext->request_scp;
7d0efb59 3119
c0b6e17e 3120 if (shot_ext->shot.dm.request.frameCount == 0) {
4aa4d739 3121 CAM_LOGE("ERR(%s): dm.request.frameCount = %d", __FUNCTION__, shot_ext->shot.dm.request.frameCount);
c0b6e17e
C		 3122 }
3123
ad37861e 3124 cam_int_qbuf(&(m_camera_info.isp), index);
13d8c7b4 3125
ad37861e 3126 usleep(10000);
13d8c7b4 3127
ad37861e
SK		 3128 ALOGV("### isp DQBUF start");
3129 index_isp = cam_int_dqbuf(&(m_camera_info.isp));
ef6f83ca 3130
ad37861e 3131 shot_ext = (struct camera2_shot_ext *)(m_camera_info.isp.buffer[index_isp].virt.extP[1]);
13d8c7b4 3132
e117f756
YJ		 3133 if (m_ctlInfo.flash.m_flashEnableFlg)
3134 m_preCaptureListenerISP(shot_ext);
9a710a45 3135
5506cebf 3136 ALOGV("### Isp DQbuf done(%d) count (%d), SCP(%d) SCC(%d) dis_bypass(%d) shot_size(%d)",
ad37861e
SK		 3137 index,
3138 shot_ext->shot.ctl.request.frameCount,
3139 shot_ext->request_scp,
3140 shot_ext->request_scc,
3141 shot_ext->dis_bypass, sizeof(camera2_shot));
ef6f83ca 3142 ALOGV("(%s): DM aa(%d) aemode(%d) awb(%d) afmode(%d)", __FUNCTION__,
8e2c2fdb
SK		 3143 (int)(shot_ext->shot.dm.aa.mode), (int)(shot_ext->shot.dm.aa.aeMode),
3144 (int)(shot_ext->shot.dm.aa.awbMode),
3145 (int)(shot_ext->shot.dm.aa.afMode));
13d8c7b4 3146
5506cebf 3147 m_currentOutputStreams = shot_ext->shot.ctl.request.outputStreams[0];
2adfa429
JS		 3148
3149 if (current_scp) {
3150 ALOGV("send SIGNAL_STREAM_DATA_COMING(return scp : %d)", shot_ext->request_scp);
b55ed664 3151 m_scpOutputSignalCnt++;
ad37861e
SK		 3152 m_streamThreads[0]->SetSignal(SIGNAL_STREAM_DATA_COMING);
3153 }
7d0efb59
C		 3154
3155 if (current_scp != shot_ext->request_scp) {
4aa4d739 3156 CAM_LOGW("WARN(%s): scp frame drop1 request_scp(%d to %d)",
7d0efb59
C		 3157 __FUNCTION__, current_scp, shot_ext->request_scp);
3158 }
15fd8231 3159 if (shot_ext->request_scc) {
a15b4e3f 3160 memcpy(&m_jpegMetadata, &shot_ext->shot, sizeof(struct camera2_shot));
15fd8231
SK		 3161 m_streamThreads[1]->SetSignal(SIGNAL_STREAM_DATA_COMING);
3162 }
c15a6b00 3163
ad37861e
SK		 3164 ALOGV("(%s): SCP_CLOSING check sensor(%d) scc(%d) scp(%d) ", __FUNCTION__,
3165 shot_ext->request_sensor, shot_ext->request_scc, shot_ext->request_scp);
3166 if (shot_ext->request_scc + shot_ext->request_scp + shot_ext->request_sensor == 0) {
3167 ALOGV("(%s): SCP_CLOSING check OK ", __FUNCTION__);
3168 m_scp_closed = true;
3169 }
3170 else
3171 m_scp_closed = false;
c15a6b00 3172
fd2d78a2
SK		 3173 if (!shot_ext->fd_bypass) {
3174 /* FD orientation axis transformation */
3175 for (int i=0; i < CAMERA2_MAX_FACES; i++) {
3176 if (shot_ext->shot.dm.stats.faceRectangles[i][0] > 0)
3177 shot_ext->shot.dm.stats.faceRectangles[i][0] = (m_camera2->m_curCameraInfo->sensorW
ef6f83ca 3178 * shot_ext->shot.dm.stats.faceRectangles[i][0])
5506cebf 3179 / m_streamThreads[0].get()->m_parameters.width;
fd2d78a2
SK		 3180 if (shot_ext->shot.dm.stats.faceRectangles[i][1] > 0)
3181 shot_ext->shot.dm.stats.faceRectangles[i][1] = (m_camera2->m_curCameraInfo->sensorH
ef6f83ca 3182 * shot_ext->shot.dm.stats.faceRectangles[i][1])
5506cebf 3183 / m_streamThreads[0].get()->m_parameters.height;
fd2d78a2
SK		 3184 if (shot_ext->shot.dm.stats.faceRectangles[i][2] > 0)
3185 shot_ext->shot.dm.stats.faceRectangles[i][2] = (m_camera2->m_curCameraInfo->sensorW
ef6f83ca 3186 * shot_ext->shot.dm.stats.faceRectangles[i][2])
5506cebf 3187 / m_streamThreads[0].get()->m_parameters.width;
fd2d78a2
SK		 3188 if (shot_ext->shot.dm.stats.faceRectangles[i][3] > 0)
3189 shot_ext->shot.dm.stats.faceRectangles[i][3] = (m_camera2->m_curCameraInfo->sensorH
ef6f83ca 3190 * shot_ext->shot.dm.stats.faceRectangles[i][3])
5506cebf 3191 / m_streamThreads[0].get()->m_parameters.height;
fd2d78a2
SK		 3192 }
3193 }
e117f756 3194 if (m_nightCaptureCnt == 0 && (m_ctlInfo.flash.m_flashCnt < IS_FLASH_STATE_CAPTURE)) {
a15b4e3f
SK		 3195 m_requestManager->ApplyDynamicMetadata(shot_ext);
3196 }
0f26b20f 3197 OnAfNotification(shot_ext->shot.dm.aa.afState);
e117f756 3198 OnPrecaptureMeteringNotification();
ad37861e 3199 }
13d8c7b4 3200
52f54308
SK		 3201 index = m_requestManager->popSensorQ();
3202 if(index < 0){
3203 ALOGE("sensorQ is empty");
3204 return;
3205 }
3206
0f26b20f 3207 processingReqIndex = m_requestManager->MarkProcessingRequest(&(m_camera_info.sensor.buffer[index]), &afMode);
ef6f83ca 3208 if (processingReqIndex != -1)
0f26b20f 3209 SetAfMode((enum aa_afmode)afMode);
ef6f83ca 3210
9dd63e1f 3211
ad37861e
SK		 3212 shot_ext = (struct camera2_shot_ext *)(m_camera_info.sensor.buffer[index].virt.extP[1]);
3213 if (m_scp_closing || m_scp_closed) {
3214 ALOGD("(%s): SCP_CLOSING(%d) SCP_CLOSED(%d)", __FUNCTION__, m_scp_closing, m_scp_closed);
3215 shot_ext->request_scc = 0;
3216 shot_ext->request_scp = 0;
3217 shot_ext->request_sensor = 0;
3218 }
ad37861e 3219 cam_int_qbuf(&(m_camera_info.sensor), index);
52f54308 3220 ALOGV("Sensor Qbuf done(%d)", index);
c15a6b00 3221
ef6f83ca
SK		 3222 if (!m_scp_closing
3223 && ((matchedFrameCnt == -1) || (processingReqIndex == -1))){
da7ca692 3224 ALOGV("make bubble shot: matchedFramcnt(%d) processingReqIndex(%d)",
ef6f83ca 3225 matchedFrameCnt, processingReqIndex);
ad37861e
SK		 3226 selfThread->SetSignal(SIGNAL_SENSOR_START_REQ_PROCESSING);
3227 }
c15a6b00 3228 }
ad37861e
SK		 3229 return;
3230}
9dd63e1f 3231
86646da4
SK		 3232void ExynosCameraHWInterface2::m_streamBufferInit(SignalDrivenThread *self)
3233{
3234 uint32_t currentSignal = self->GetProcessingSignal();
3235 StreamThread * selfThread = ((StreamThread*)self);
3236 stream_parameters_t *selfStreamParms = &(selfThread->m_parameters);
5506cebf
SK		 3237 node_info_t *currentNode = selfStreamParms->node;
3238 substream_parameters_t *subParms;
86646da4
SK		 3239 buffer_handle_t * buf = NULL;
3240 status_t res;
3241 void *virtAddr[3];
3242 int i, j;
3243 int index;
3244 nsecs_t timestamp;
3245
3246 if (!(selfThread->m_isBufferInit))
3247 {
3248 for ( i=0 ; i < selfStreamParms->numSvcBuffers; i++) {
3249 res = selfStreamParms->streamOps->dequeue_buffer(selfStreamParms->streamOps, &buf);
3250 if (res != NO_ERROR || buf == NULL) {
3251 ALOGE("ERR(%s): Init: unable to dequeue buffer : %d",__FUNCTION__ , res);
3252 return;
3253 }
3254 ALOGV("DEBUG(%s): got buf(%x) version(%d), numFds(%d), numInts(%d)", __FUNCTION__, (uint32_t)(*buf),
3255 ((native_handle_t*)(*buf))->version, ((native_handle_t*)(*buf))->numFds, ((native_handle_t*)(*buf))->numInts);
3256
5506cebf 3257 index = selfThread->findBufferIndex(buf);
86646da4
SK		 3258 if (index == -1) {
3259 ALOGE("ERR(%s): could not find buffer index", __FUNCTION__);
3260 }
3261 else {
3262 ALOGV("DEBUG(%s): found buffer index[%d] - status(%d)",
3263 __FUNCTION__, index, selfStreamParms->svcBufStatus[index]);
3264 if (selfStreamParms->svcBufStatus[index]== REQUIRES_DQ_FROM_SVC)
3265 selfStreamParms->svcBufStatus[index] = ON_DRIVER;
3266 else if (selfStreamParms->svcBufStatus[index]== ON_SERVICE)
3267 selfStreamParms->svcBufStatus[index] = ON_HAL;
3268 else {
3269 ALOGV("DBG(%s): buffer status abnormal (%d) "
3270 , __FUNCTION__, selfStreamParms->svcBufStatus[index]);
3271 }
3272 selfStreamParms->numSvcBufsInHal++;
86646da4 3273 }
5506cebf 3274 selfStreamParms->bufIndex = 0;
86646da4
SK		 3275 }
3276 selfThread->m_isBufferInit = true;
3277 }
5506cebf
SK		 3278 for (int i = 0 ; i < NUM_MAX_SUBSTREAM ; i++) {
3279 if (selfThread->m_attachedSubStreams[i].streamId == -1)
3280 continue;
86646da4 3281
5506cebf
SK		 3282 subParms = &m_subStreams[selfThread->m_attachedSubStreams[i].streamId];
3283 if (subParms->type && subParms->needBufferInit) {
3284 ALOGV("(%s): [subStream] (id:%d) Buffer Initialization numsvcbuf(%d)",
3285 __FUNCTION__, selfThread->m_attachedSubStreams[i].streamId, subParms->numSvcBuffers);
74d78ebe
SK		 3286 int checkingIndex = 0;
3287 bool found = false;
5506cebf
SK		 3288 for ( i = 0 ; i < subParms->numSvcBuffers; i++) {
3289 res = subParms->streamOps->dequeue_buffer(subParms->streamOps, &buf);
74d78ebe
SK		 3290 if (res != NO_ERROR || buf == NULL) {
3291 ALOGE("ERR(%s): Init: unable to dequeue buffer : %d",__FUNCTION__ , res);
3292 return;
3293 }
5506cebf
SK		 3294 subParms->numSvcBufsInHal++;
3295 ALOGV("DEBUG(%s): [subStream] got buf(%x) bufInHal(%d) version(%d), numFds(%d), numInts(%d)", __FUNCTION__, (uint32_t)(*buf),
3296 subParms->numSvcBufsInHal, ((native_handle_t*)(*buf))->version, ((native_handle_t*)(*buf))->numFds, ((native_handle_t*)(*buf))->numInts);
74d78ebe
SK		 3297
3298 if (m_grallocHal->lock(m_grallocHal, *buf,
5506cebf
SK		 3299 subParms->usage, 0, 0,
3300 subParms->width, subParms->height, virtAddr) != 0) {
74d78ebe
SK		 3301 ALOGE("ERR(%s): could not obtain gralloc buffer", __FUNCTION__);
3302 }
3303 else {
5506cebf 3304 ALOGV("DEBUG(%s): [subStream] locked img buf plane0(%x) plane1(%x) plane2(%x)",
74d78ebe
SK		 3305 __FUNCTION__, (unsigned int)virtAddr[0], (unsigned int)virtAddr[1], (unsigned int)virtAddr[2]);
3306 }
3307 found = false;
5506cebf
SK		 3308 for (checkingIndex = 0; checkingIndex < subParms->numSvcBuffers ; checkingIndex++) {
3309 if (subParms->svcBufHandle[checkingIndex] == *buf ) {
74d78ebe
SK		 3310 found = true;
3311 break;
3312 }
3313 }
5506cebf 3314 ALOGV("DEBUG(%s): [subStream] found(%d) - index[%d]", __FUNCTION__, found, checkingIndex);
74d78ebe
SK		 3315 if (!found) break;
3316
3317 index = checkingIndex;
3318
3319 if (index == -1) {
3320 ALOGV("ERR(%s): could not find buffer index", __FUNCTION__);
3321 }
3322 else {
3323 ALOGV("DEBUG(%s): found buffer index[%d] - status(%d)",
5506cebf
SK		 3324 __FUNCTION__, index, subParms->svcBufStatus[index]);
3325 if (subParms->svcBufStatus[index]== ON_SERVICE)
3326 subParms->svcBufStatus[index] = ON_HAL;
74d78ebe
SK		 3327 else {
3328 ALOGV("DBG(%s): buffer status abnormal (%d) "
5506cebf 3329 , __FUNCTION__, subParms->svcBufStatus[index]);
74d78ebe 3330 }
5506cebf 3331 if (*buf != subParms->svcBufHandle[index])
74d78ebe
SK		 3332 ALOGV("DBG(%s): different buf_handle index ", __FUNCTION__);
3333 else
3334 ALOGV("DEBUG(%s): same buf_handle index", __FUNCTION__);
3335 }
5506cebf 3336 subParms->svcBufIndex = 0;
74d78ebe 3337 }
5506cebf
SK		 3338 if (subParms->type == SUBSTREAM_TYPE_JPEG) {
3339 m_resizeBuf.size.extS[0] = ALIGN(subParms->width, 16) * ALIGN(subParms->height, 16) * 2;
3340 m_resizeBuf.size.extS[1] = 0;
3341 m_resizeBuf.size.extS[2] = 0;
3342
3343 if (allocCameraMemory(m_ionCameraClient, &m_resizeBuf, 1) == -1) {
3344 ALOGE("ERR(%s): Failed to allocate resize buf", __FUNCTION__);
3345 }
3346 }
3347 if (subParms->type == SUBSTREAM_TYPE_PRVCB) {
3348 m_getAlignedYUVSize(HAL_PIXEL_FORMAT_2_V4L2_PIX(subParms->internalFormat), subParms->width,
3349 subParms->height, &m_previewCbBuf);
86646da4 3350
5506cebf
SK		 3351 if (allocCameraMemory(m_ionCameraClient, &m_previewCbBuf, subParms->internalPlanes) == -1) {
3352 ALOGE("ERR(%s): Failed to allocate prvcb buf", __FUNCTION__);
3353 }
3354 }
3355 subParms->needBufferInit= false;
3356 }
3357 }
86646da4
SK		 3358}
3359
c15a6b00
JS		 3360void ExynosCameraHWInterface2::m_streamThreadInitialize(SignalDrivenThread * self)
3361{
13d8c7b4
SK		 3362 StreamThread * selfThread = ((StreamThread*)self);
3363 ALOGV("DEBUG(%s): ", __FUNCTION__ );
3364 memset(&(selfThread->m_parameters), 0, sizeof(stream_parameters_t));
3365 selfThread->m_isBufferInit = false;
5506cebf
SK		 3366 for (int i = 0 ; i < NUM_MAX_SUBSTREAM ; i++) {
3367 selfThread->m_attachedSubStreams[i].streamId = -1;
3368 selfThread->m_attachedSubStreams[i].priority = 0;
3369 }
c15a6b00
JS		 3370 return;
3371}
3372
5506cebf
SK		 3373int ExynosCameraHWInterface2::m_runSubStreamFunc(StreamThread *selfThread, ExynosBuffer *srcImageBuf,
3374 int stream_id, nsecs_t frameTimeStamp)
c15a6b00 3375{
5506cebf
SK		 3376 substream_parameters_t *subParms = &m_subStreams[stream_id];
3377
3378 switch (stream_id) {
c15a6b00 3379
5506cebf
SK		 3380 case STREAM_ID_JPEG:
3381 return m_jpegCreator(selfThread, srcImageBuf, frameTimeStamp);
c15a6b00 3382
5506cebf
SK		 3383 case STREAM_ID_RECORD:
3384 return m_recordCreator(selfThread, srcImageBuf, frameTimeStamp);
3385
3386 case STREAM_ID_PRVCB:
3387 return m_prvcbCreator(selfThread, srcImageBuf, frameTimeStamp);
3388
3389 default:
3390 return 0;
c15a6b00 3391 }
5506cebf
SK		 3392}
3393void ExynosCameraHWInterface2::m_streamFunc_direct(SignalDrivenThread *self)
3394{
3395 uint32_t currentSignal = self->GetProcessingSignal();
3396 StreamThread * selfThread = ((StreamThread*)self);
3397 stream_parameters_t *selfStreamParms = &(selfThread->m_parameters);
3398 node_info_t *currentNode = selfStreamParms->node;
3399 int i = 0;
3400 nsecs_t frameTimeStamp;
13d8c7b4 3401
b55ed664 3402 if (currentSignal & SIGNAL_THREAD_RELEASE) {
5506cebf 3403 CAM_LOGD("(%s): [%d] START SIGNAL_THREAD_RELEASE", __FUNCTION__, selfThread->m_index);
b55ed664
SK		 3404
3405 if (selfThread->m_isBufferInit) {
5506cebf
SK		 3406 ALOGV("(%s): [%d] calling streamoff (fd:%d)", __FUNCTION__,
3407 selfThread->m_index, currentNode->fd);
3408 if (cam_int_streamoff(currentNode) < 0 ) {
b55ed664 3409 ALOGE("ERR(%s): stream off fail", __FUNCTION__);
b55ed664 3410 }
5506cebf
SK		 3411 ALOGV("(%s): [%d] streamoff done and calling reqbuf 0 (fd:%d)", __FUNCTION__,
3412 selfThread->m_index, currentNode->fd);
b55ed664
SK		 3413 currentNode->buffers = 0;
3414 cam_int_reqbufs(currentNode);
5506cebf
SK		 3415 ALOGV("(%s): [%d] reqbuf 0 DONE (fd:%d)", __FUNCTION__,
3416 selfThread->m_index, currentNode->fd);
b55ed664
SK		 3417 }
3418#ifdef ENABLE_FRAME_SYNC
3419 // free metabuffers
5506cebf
SK		 3420 for (i = 0; i < NUM_MAX_CAMERA_BUFFERS; i++)
3421 if (selfStreamParms->metaBuffers[i].fd.extFd[0] != 0) {
b55ed664
SK		 3422 freeCameraMemory(&(selfStreamParms->metaBuffers[i]), 1);
3423 selfStreamParms->metaBuffers[i].fd.extFd[0] = 0;
3424 selfStreamParms->metaBuffers[i].size.extS[0] = 0;
3425 }
3426#endif
3427 selfThread->m_isBufferInit = false;
b55ed664 3428 selfThread->m_releasing = false;
5506cebf
SK		 3429 selfThread->m_activated = false;
3430 ALOGV("(%s): [%d] END SIGNAL_THREAD_RELEASE", __FUNCTION__, selfThread->m_index);
3431 return;
3432 }
3433 if (currentSignal & SIGNAL_STREAM_REPROCESSING_START) {
3434 status_t res;
3435 buffer_handle_t * buf = NULL;
3436 bool found = false;
3437 ALOGV("(%s): streamthread[%d] START SIGNAL_STREAM_REPROCESSING_START",
3438 __FUNCTION__, selfThread->m_index);
3439 res = m_reprocessOps->acquire_buffer(m_reprocessOps, &buf);
3440 if (res != NO_ERROR || buf == NULL) {
3441 ALOGE("ERR(%s): [reprocess] unable to acquire_buffer : %d",__FUNCTION__ , res);
3442 return;
3443 }
3444 const private_handle_t *priv_handle = reinterpret_cast<const private_handle_t *>(*buf);
3445 int checkingIndex = 0;
3446 for (checkingIndex = 0; checkingIndex < selfStreamParms->numSvcBuffers ; checkingIndex++) {
3447 if (priv_handle->fd == selfStreamParms->svcBuffers[checkingIndex].fd.extFd[0] ) {
3448 found = true;
3449 break;
3450 }
3451 }
3452 ALOGV("DEBUG(%s): dequeued buf %x => found(%d) index(%d) ",
3453 __FUNCTION__, (unsigned int)buf, found, checkingIndex);
b55ed664 3454
5506cebf
SK		 3455 if (!found) return;
3456
3457 for (int i = 0 ; i < NUM_MAX_SUBSTREAM ; i++) {
3458 if (selfThread->m_attachedSubStreams[i].streamId == -1)
3459 continue;
3460
3461#ifdef ENABLE_FRAME_SYNC
3462 // TODO: check real timestamp
3463 frameTimeStamp = m_requestManager->GetTimestamp(m_requestManager->GetFrameIndex());
3464 m_requestManager->NotifyStreamOutput(m_reprocessingFrameCnt);
3465#else
3466 frameTimeStamp = m_requestManager->GetTimestamp(m_requestManager->GetFrameIndex());
3467#endif
3468 if (m_currentReprocessOutStreams & (1<<selfThread->m_attachedSubStreams[i].streamId))
3469 m_runSubStreamFunc(selfThread, &(selfStreamParms->svcBuffers[checkingIndex]),
3470 selfThread->m_attachedSubStreams[i].streamId, frameTimeStamp);
3471 }
3472
3473 res = m_reprocessOps->release_buffer(m_reprocessOps, buf);
3474 if (res != NO_ERROR) {
3475 ALOGE("ERR(%s): [reprocess] unable to release_buffer : %d",__FUNCTION__ , res);
3476 return;
3477 }
3478 ALOGV("(%s): streamthread[%d] END SIGNAL_STREAM_REPROCESSING_START",
3479 __FUNCTION__,selfThread->m_index);
b55ed664
SK		 3480
3481 return;
3482 }
13d8c7b4 3483 if (currentSignal & SIGNAL_STREAM_DATA_COMING) {
c15a6b00 3484 buffer_handle_t * buf = NULL;
5506cebf 3485 status_t res = 0;
c15a6b00
JS		 3486 int i, j;
3487 int index;
ad37861e 3488 nsecs_t timestamp;
5506cebf 3489#ifdef ENABLE_FRAME_SYNC
feb7df4c 3490 camera2_stream *frame;
5506cebf 3491#endif
c0b6e17e 3492 int numOfUndqbuf = 0;
c0b6e17e 3493
5506cebf 3494 ALOGV("(%s): streamthread[%d] START SIGNAL_STREAM_DATA_COMING", __FUNCTION__,selfThread->m_index);
ad37861e 3495
86646da4 3496 m_streamBufferInit(self);
c15a6b00 3497
b5237e6b 3498 do {
5506cebf
SK		 3499 ALOGV("DEBUG(%s): streamthread[%d] type(%d) DQBUF START ",__FUNCTION__,
3500 selfThread->m_index, selfThread->streamType);
b5237e6b 3501
feb7df4c 3502#ifdef ENABLE_FRAME_SYNC
5506cebf
SK		 3503 selfStreamParms->bufIndex = cam_int_dqbuf(currentNode, selfStreamParms->planes + selfStreamParms->metaPlanes);
3504 frame = (struct camera2_stream *)(selfStreamParms->metaBuffers[selfStreamParms->bufIndex].virt.extP[0]);
3505 ALOGV("frame count streamthread[%d] : %d", selfThread->m_index, frame->rcount);
3506 frameTimeStamp = m_requestManager->GetTimestampByFrameCnt(frame->rcount);
feb7df4c 3507#else
5506cebf
SK		 3508 selfStreamParms->bufIndex = cam_int_dqbuf(currentNode);
3509 frameTimeStamp = m_requestManager->GetTimestamp(m_requestManager->GetFrameIndex())
feb7df4c 3510#endif
5506cebf
SK		 3511 ALOGV("DEBUG(%s): streamthread[%d] DQBUF done index(%d) sigcnt(%d)",__FUNCTION__,
3512 selfThread->m_index, selfStreamParms->bufIndex, m_scpOutputSignalCnt);
804236a7 3513
5506cebf 3514 if (selfStreamParms->svcBufStatus[selfStreamParms->bufIndex] != ON_DRIVER)
86646da4 3515 ALOGV("DBG(%s): DQed buffer status abnormal (%d) ",
5506cebf
SK		 3516 __FUNCTION__, selfStreamParms->svcBufStatus[selfStreamParms->bufIndex]);
3517 selfStreamParms->svcBufStatus[selfStreamParms->bufIndex] = ON_HAL;
b5237e6b 3518
5506cebf
SK		 3519 for (int i = 0 ; i < NUM_MAX_SUBSTREAM ; i++) {
3520 if (selfThread->m_attachedSubStreams[i].streamId == -1)
3521 continue;
3522 if (m_currentOutputStreams & (1<<selfThread->m_attachedSubStreams[i].streamId)) {
3523#ifdef ENABLE_FRAME_SYNC
3524 m_requestManager->NotifyStreamOutput(frame->rcount);
3525#endif
3526 m_runSubStreamFunc(selfThread, &(selfStreamParms->svcBuffers[selfStreamParms->bufIndex]),
3527 selfThread->m_attachedSubStreams[i].streamId, frameTimeStamp);
b5237e6b 3528 }
86646da4 3529 }
c0b6e17e 3530
5506cebf
SK		 3531#ifdef ENABLE_FRAME_SYNC
3532 m_requestManager->NotifyStreamOutput(frame->rcount);
3533#endif
3534 if (m_requestManager->GetSkipCnt() <= 0) {
3535 if ((m_currentOutputStreams & STREAM_MASK_PREVIEW) && selfThread->m_index == 0) {
3536#ifdef ENABLE_FRAME_SYNC
3537 ALOGV("** Display Preview(frameCnt:%d)", frame->rcount);
3538#else
3539 ALOGV("** Display Preview(frameCnt:%d)", m_requestManager->GetFrameIndex());
3540#endif
3541 res = selfStreamParms->streamOps->enqueue_buffer(selfStreamParms->streamOps,
3542 frameTimeStamp,
3543 &(selfStreamParms->svcBufHandle[selfStreamParms->bufIndex]));
74d78ebe 3544 }
5506cebf
SK		 3545 else if ((m_currentOutputStreams & STREAM_MASK_ZSL) && selfThread->m_index == 1) {
3546#ifdef ENABLE_FRAME_SYNC
3547 ALOGV("** SCC output (frameCnt:%d), last(%d)", frame->rcount);
3548#else
3549 ALOGV("** SCC output (frameCnt:%d), last(%d)", m_requestManager->GetFrameIndex());
3550#endif
3551 res = selfStreamParms->streamOps->enqueue_buffer(selfStreamParms->streamOps,
3552 frameTimeStamp,
3553 &(selfStreamParms->svcBufHandle[selfStreamParms->bufIndex]));
74d78ebe 3554 }
5506cebf 3555 ALOGV("DEBUG(%s): streamthread[%d] enqueue_buffer to svc done res(%d)", __FUNCTION__, selfThread->m_index, res);
86646da4
SK		 3556 }
3557 else {
3558 res = selfStreamParms->streamOps->cancel_buffer(selfStreamParms->streamOps,
5506cebf
SK		 3559 &(selfStreamParms->svcBufHandle[selfStreamParms->bufIndex]));
3560 ALOGV("DEBUG(%s): streamthread[%d] cancel_buffer to svc done res(%d)", __FUNCTION__, selfThread->m_index, res);
86646da4
SK		 3561 }
3562 if (res == 0) {
5506cebf 3563 selfStreamParms->svcBufStatus[selfStreamParms->bufIndex] = ON_SERVICE;
86646da4
SK		 3564 selfStreamParms->numSvcBufsInHal--;
3565 }
3566 else {
5506cebf 3567 selfStreamParms->svcBufStatus[selfStreamParms->bufIndex] = ON_HAL;
b5237e6b 3568 }
86646da4 3569
c15a6b00 3570 }
ce8e830a 3571 while(0);
b5237e6b 3572
b55ed664 3573 while (selfStreamParms->numSvcBufsInHal < selfStreamParms->numOwnSvcBuffers - 1) {
86646da4
SK		 3574 res = selfStreamParms->streamOps->dequeue_buffer(selfStreamParms->streamOps, &buf);
3575 if (res != NO_ERROR || buf == NULL) {
5506cebf 3576 ALOGV("DEBUG(%s): streamthread[%d] dequeue_buffer fail res(%d)",__FUNCTION__ , selfThread->m_index, res);
86646da4
SK		 3577 break;
3578 }
3579 selfStreamParms->numSvcBufsInHal++;
5506cebf 3580 ALOGV("DEBUG(%s): streamthread[%d] got buf(%x) numInHal(%d) version(%d), numFds(%d), numInts(%d)", __FUNCTION__,
86646da4
SK		 3581 selfThread->m_index, (uint32_t)(*buf), selfStreamParms->numSvcBufsInHal,
3582 ((native_handle_t*)(*buf))->version, ((native_handle_t*)(*buf))->numFds, ((native_handle_t*)(*buf))->numInts);
3583 const private_handle_t *priv_handle = reinterpret_cast<const private_handle_t *>(*buf);
3584
3585 bool found = false;
3586 int checkingIndex = 0;
3587 for (checkingIndex = 0; checkingIndex < selfStreamParms->numSvcBuffers ; checkingIndex++) {
3588 if (priv_handle->fd == selfStreamParms->svcBuffers[checkingIndex].fd.extFd[0] ) {
3589 found = true;
9dd63e1f
SK		 3590 break;
3591 }
86646da4 3592 }
86646da4 3593 if (!found) break;
5506cebf
SK		 3594 selfStreamParms->bufIndex = checkingIndex;
3595 if (selfStreamParms->bufIndex < selfStreamParms->numHwBuffers) {
86646da4 3596 uint32_t plane_index = 0;
5506cebf 3597 ExynosBuffer* currentBuf = &(selfStreamParms->svcBuffers[selfStreamParms->bufIndex]);
86646da4
SK		 3598 struct v4l2_buffer v4l2_buf;
3599 struct v4l2_plane planes[VIDEO_MAX_PLANES];
13d8c7b4 3600
86646da4
SK		 3601 v4l2_buf.m.planes = planes;
3602 v4l2_buf.type = currentNode->type;
3603 v4l2_buf.memory = currentNode->memory;
5506cebf 3604 v4l2_buf.index = selfStreamParms->bufIndex;
86646da4
SK		 3605 v4l2_buf.length = currentNode->planes;
3606
5506cebf
SK		 3607 v4l2_buf.m.planes[0].m.fd = priv_handle->fd;
3608 v4l2_buf.m.planes[2].m.fd = priv_handle->fd1;
3609 v4l2_buf.m.planes[1].m.fd = priv_handle->fd2;
3610 for (plane_index=0 ; plane_index < v4l2_buf.length ; plane_index++) {
3611 v4l2_buf.m.planes[plane_index].length = currentBuf->size.extS[plane_index];
3612 }
3613#ifdef ENABLE_FRAME_SYNC
3614 /* add plane for metadata*/
3615 v4l2_buf.length += selfStreamParms->metaPlanes;
3616 v4l2_buf.m.planes[v4l2_buf.length-1].m.fd = selfStreamParms->metaBuffers[selfStreamParms->bufIndex].fd.extFd[0];
3617 v4l2_buf.m.planes[v4l2_buf.length-1].length = selfStreamParms->metaBuffers[selfStreamParms->bufIndex].size.extS[0];
3618#endif
3619 if (exynos_v4l2_qbuf(currentNode->fd, &v4l2_buf) < 0) {
3620 ALOGE("ERR(%s): streamthread[%d] exynos_v4l2_qbuf() fail",
3621 __FUNCTION__, selfThread->m_index);
3622 return;
3623 }
3624 selfStreamParms->svcBufStatus[selfStreamParms->bufIndex] = ON_DRIVER;
3625 ALOGV("DEBUG(%s): streamthread[%d] QBUF done index(%d)",
3626 __FUNCTION__, selfThread->m_index, selfStreamParms->bufIndex);
3627 }
3628 }
3629
3630 ALOGV("(%s): streamthread[%d] END SIGNAL_STREAM_DATA_COMING", __FUNCTION__,selfThread->m_index);
3631 }
3632 return;
3633}
3634
3635void ExynosCameraHWInterface2::m_streamFunc_indirect(SignalDrivenThread *self)
3636{
3637 uint32_t currentSignal = self->GetProcessingSignal();
3638 StreamThread * selfThread = ((StreamThread*)self);
3639 stream_parameters_t *selfStreamParms = &(selfThread->m_parameters);
3640 node_info_t *currentNode = selfStreamParms->node;
3641
3642
3643 if (currentSignal & SIGNAL_THREAD_RELEASE) {
3644 CAM_LOGV("(%s): [%d] START SIGNAL_THREAD_RELEASE", __FUNCTION__, selfThread->m_index);
3645
3646 if (selfThread->m_isBufferInit) {
3647 if (currentNode->fd == m_camera_info.capture.fd) {
3648 if (m_camera_info.capture.status == true) {
3649 ALOGV("DEBUG(%s): calling streamthread[%d] streamoff (fd:%d)", __FUNCTION__,
3650 selfThread->m_index, currentNode->fd);
3651 if (cam_int_streamoff(currentNode) < 0 ){
3652 ALOGE("ERR(%s): stream off fail", __FUNCTION__);
3653 } else {
3654 m_camera_info.capture.status = false;
3655 }
3656 }
3657 } else {
3658 ALOGV("DEBUG(%s): calling streamthread[%d] streamoff (fd:%d)", __FUNCTION__,
3659 selfThread->m_index, currentNode->fd);
3660 if (cam_int_streamoff(currentNode) < 0 ){
3661 ALOGE("ERR(%s): stream off fail", __FUNCTION__);
3662 }
3663 }
3664 ALOGV("DEBUG(%s): calling streamthread[%d] streamoff done", __FUNCTION__, selfThread->m_index);
3665 ALOGV("DEBUG(%s): calling streamthread[%d] reqbuf 0 (fd:%d)", __FUNCTION__,
3666 selfThread->m_index, currentNode->fd);
3667 currentNode->buffers = 0;
3668 cam_int_reqbufs(currentNode);
3669 ALOGV("DEBUG(%s): calling streamthread[%d] reqbuf 0 DONE(fd:%d)", __FUNCTION__,
3670 selfThread->m_index, currentNode->fd);
3671 }
3672
3673 selfThread->m_isBufferInit = false;
3674 selfThread->m_releasing = false;
3675 selfThread->m_activated = false;
3676 ALOGV("(%s): [%d] END SIGNAL_THREAD_RELEASE", __FUNCTION__, selfThread->m_index);
3677 return;
3678 }
3679
3680 if (currentSignal & SIGNAL_STREAM_DATA_COMING) {
3681#ifdef ENABLE_FRAME_SYNC
3682 camera2_stream *frame;
3683#endif
3684 nsecs_t frameTimeStamp;
3685
3686 ALOGV("DEBUG(%s): streamthread[%d] processing SIGNAL_STREAM_DATA_COMING",
3687 __FUNCTION__,selfThread->m_index);
3688
3689 m_streamBufferInit(self);
3690
ed4ad5fe 3691 ALOGV("DEBUG(%s): streamthread[%d] DQBUF START", __FUNCTION__, selfThread->m_index);
5506cebf 3692 selfStreamParms->bufIndex = cam_int_dqbuf(currentNode);
ed4ad5fe 3693 ALOGV("DEBUG(%s): streamthread[%d] DQBUF done index(%d)",__FUNCTION__,
5506cebf
SK		 3694 selfThread->m_index, selfStreamParms->bufIndex);
3695
3696#ifdef ENABLE_FRAME_SYNC
3697 frame = (struct camera2_stream *)(currentNode->buffer[selfStreamParms->bufIndex].virt.extP[selfStreamParms->planes -1]);
3698 ALOGV("frame count(SCC) : %d", frame->rcount);
3699 frameTimeStamp = m_requestManager->GetTimestampByFrameCnt(frame->rcount);
3700#else
3701 frameTimeStamp = m_requestManager->GetTimestamp(m_requestManager->GetFrameIndex());
3702#endif
3703
3704 for (int i = 0 ; i < NUM_MAX_SUBSTREAM ; i++) {
3705 if (selfThread->m_attachedSubStreams[i].streamId == -1)
3706 continue;
3707 if (m_currentOutputStreams & (1<<selfThread->m_attachedSubStreams[i].streamId)) {
feb7df4c 3708#ifdef ENABLE_FRAME_SYNC
5506cebf 3709 m_requestManager->NotifyStreamOutput(frame->rcount);
feb7df4c 3710#endif
5506cebf
SK		 3711 m_runSubStreamFunc(selfThread, &(currentNode->buffer[selfStreamParms->bufIndex]),
3712 selfThread->m_attachedSubStreams[i].streamId, frameTimeStamp);
be494d19
SK		 3713 }
3714 }
5506cebf
SK		 3715 cam_int_qbuf(currentNode, selfStreamParms->bufIndex);
3716 ALOGV("DEBUG(%s): streamthread[%d] QBUF DONE", __FUNCTION__, selfThread->m_index);
86646da4 3717
5506cebf
SK		 3718
3719
3720 ALOGV("DEBUG(%s): streamthread[%d] processing SIGNAL_STREAM_DATA_COMING DONE",
3721 __FUNCTION__, selfThread->m_index);
86646da4 3722 }
5506cebf
SK		 3723
3724
86646da4
SK		 3725 return;
3726}
3727
5506cebf 3728void ExynosCameraHWInterface2::m_streamThreadFunc(SignalDrivenThread * self)
86646da4
SK		 3729{
3730 uint32_t currentSignal = self->GetProcessingSignal();
3731 StreamThread * selfThread = ((StreamThread*)self);
3732 stream_parameters_t *selfStreamParms = &(selfThread->m_parameters);
5506cebf
SK		 3733 node_info_t *currentNode = selfStreamParms->node;
3734
3735 ALOGV("DEBUG(%s): m_streamThreadFunc[%d] (%x)", __FUNCTION__, selfThread->m_index, currentSignal);
86646da4 3736
5506cebf
SK		 3737 // Do something in Child thread handler
3738 // Should change function to class that inherited StreamThread class to support dynamic stream allocation
3739 if (selfThread->streamType == STREAM_TYPE_DIRECT) {
3740 m_streamFunc_direct(self);
3741 } else if (selfThread->streamType == STREAM_TYPE_INDIRECT) {
3742 m_streamFunc_indirect(self);
3743 }
86646da4 3744
5506cebf
SK		 3745 return;
3746}
3747int ExynosCameraHWInterface2::m_jpegCreator(StreamThread *selfThread, ExynosBuffer *srcImageBuf, nsecs_t frameTimeStamp)
3748{
3749 stream_parameters_t *selfStreamParms = &(selfThread->m_parameters);
3750 substream_parameters_t *subParms = &m_subStreams[STREAM_ID_JPEG];
3751 status_t res;
3752 ExynosRect jpegRect;
3753 bool found = false;
3754 int pictureW, pictureH, pictureFramesize = 0;
3755 int pictureFormat;
3756 int cropX, cropY, cropW, cropH = 0;
3757 ExynosBuffer resizeBufInfo;
3758 ExynosRect m_jpegPictureRect;
3759 buffer_handle_t * buf = NULL;
86646da4 3760
5506cebf
SK		 3761 ALOGV("DEBUG(%s): index(%d)",__FUNCTION__, subParms->svcBufIndex);
3762 for (int i = 0 ; subParms->numSvcBuffers ; i++) {
3763 if (subParms->svcBufStatus[subParms->svcBufIndex] == ON_HAL) {
3764 found = true;
3765 break;
86646da4 3766 }
5506cebf
SK		 3767 subParms->svcBufIndex++;
3768 if (subParms->svcBufIndex >= subParms->numSvcBuffers)
3769 subParms->svcBufIndex = 0;
3770 }
3771 if (!found) {
3772 ALOGE("(%s): cannot find free svc buffer", __FUNCTION__);
3773 subParms->svcBufIndex++;
3774 return 1;
86646da4
SK		 3775 }
3776
5506cebf
SK		 3777 m_jpegPictureRect.w = subParms->width;
3778 m_jpegPictureRect.h = subParms->height;
7d0efb59 3779
5506cebf
SK		 3780 ALOGV("DEBUG(%s):w = %d, h = %d, w = %d, h = %d",
3781 __FUNCTION__, selfStreamParms->width, selfStreamParms->height,
3782 m_jpegPictureRect.w, m_jpegPictureRect.h);
7d0efb59 3783
5506cebf
SK		 3784 m_getRatioSize(selfStreamParms->width, selfStreamParms->height,
3785 m_jpegPictureRect.w, m_jpegPictureRect.h,
3786 &cropX, &cropY,
3787 &pictureW, &pictureH,
3788 0);
3789 pictureFormat = V4L2_PIX_FMT_YUYV;
3790 pictureFramesize = FRAME_SIZE(V4L2_PIX_2_HAL_PIXEL_FORMAT(pictureFormat), pictureW, pictureH);
3791
3792 if (m_exynosPictureCSC) {
3793 float zoom_w = 0, zoom_h = 0;
3794 if (m_zoomRatio == 0)
3795 m_zoomRatio = 1;
3796
3797 if (m_jpegPictureRect.w >= m_jpegPictureRect.h) {
3798 zoom_w = pictureW / m_zoomRatio;
3799 zoom_h = zoom_w * m_jpegPictureRect.h / m_jpegPictureRect.w;
3800 } else {
3801 zoom_h = pictureH / m_zoomRatio;
3802 zoom_w = zoom_h * m_jpegPictureRect.w / m_jpegPictureRect.h;
7d0efb59 3803 }
5506cebf
SK		 3804 cropX = (pictureW - zoom_w) / 2;
3805 cropY = (pictureH - zoom_h) / 2;
3806 cropW = zoom_w;
3807 cropH = zoom_h;
3808
3809 ALOGV("DEBUG(%s):cropX = %d, cropY = %d, cropW = %d, cropH = %d",
3810 __FUNCTION__, cropX, cropY, cropW, cropH);
3811
3812 csc_set_src_format(m_exynosPictureCSC,
3813 ALIGN(pictureW, 16), ALIGN(pictureH, 16),
3814 cropX, cropY, cropW, cropH,
3815 V4L2_PIX_2_HAL_PIXEL_FORMAT(pictureFormat),
3816 0);
7d0efb59 3817
5506cebf
SK		 3818 csc_set_dst_format(m_exynosPictureCSC,
3819 m_jpegPictureRect.w, m_jpegPictureRect.h,
3820 0, 0, m_jpegPictureRect.w, m_jpegPictureRect.h,
3821 V4L2_PIX_2_HAL_PIXEL_FORMAT(V4L2_PIX_FMT_NV16),
3822 0);
3823 for (int i = 0 ; i < 3 ; i++)
3824 ALOGV("DEBUG(%s): m_pictureBuf.fd.extFd[%d]=%d ",
3825 __FUNCTION__, i, srcImageBuf->fd.extFd[i]);
3826 csc_set_src_buffer(m_exynosPictureCSC,
3827 (void **)&srcImageBuf->fd.fd);
7d0efb59 3828
5506cebf
SK		 3829 csc_set_dst_buffer(m_exynosPictureCSC,
3830 (void **)&m_resizeBuf.fd.fd);
3831 for (int i = 0 ; i < 3 ; i++)
3832 ALOGV("DEBUG(%s): m_resizeBuf.virt.extP[%d]=%d m_resizeBuf.size.extS[%d]=%d",
3833 __FUNCTION__, i, m_resizeBuf.fd.extFd[i], i, m_resizeBuf.size.extS[i]);
7d0efb59 3834
5506cebf
SK		 3835 if (csc_convert(m_exynosPictureCSC) != 0)
3836 ALOGE("ERR(%s): csc_convert() fail", __FUNCTION__);
3837
3838 }
3839 else {
3840 ALOGE("ERR(%s): m_exynosPictureCSC == NULL", __FUNCTION__);
7d0efb59
C		 3841 }
3842
5506cebf 3843 resizeBufInfo = m_resizeBuf;
86646da4 3844
5506cebf 3845 m_getAlignedYUVSize(V4L2_PIX_FMT_NV16, m_jpegPictureRect.w, m_jpegPictureRect.h, &m_resizeBuf);
86646da4 3846
5506cebf
SK		 3847 for (int i = 1; i < 3; i++) {
3848 if (m_resizeBuf.size.extS[i] != 0)
3849 m_resizeBuf.fd.extFd[i] = m_resizeBuf.fd.extFd[i-1] + m_resizeBuf.size.extS[i-1];
86646da4 3850
5506cebf
SK		 3851 ALOGV("(%s): m_resizeBuf.size.extS[%d] = %d", __FUNCTION__, i, m_resizeBuf.size.extS[i]);
3852 }
2adfa429 3853
5506cebf
SK		 3854 jpegRect.w = m_jpegPictureRect.w;
3855 jpegRect.h = m_jpegPictureRect.h;
3856 jpegRect.colorFormat = V4L2_PIX_FMT_NV16;
86646da4 3857
5506cebf
SK		 3858 for (int j = 0 ; j < 3 ; j++)
3859 ALOGV("DEBUG(%s): dest buf node fd.extFd[%d]=%d size=%d virt=%x ",
3860 __FUNCTION__, j, subParms->svcBuffers[subParms->svcBufIndex].fd.extFd[j],
3861 (unsigned int)subParms->svcBuffers[subParms->svcBufIndex].size.extS[j],
3862 (unsigned int)subParms->svcBuffers[subParms->svcBufIndex].virt.extP[j]);
86646da4 3863
5506cebf
SK		 3864 if (yuv2Jpeg(&m_resizeBuf, &subParms->svcBuffers[subParms->svcBufIndex], &jpegRect) == false)
3865 ALOGE("ERR(%s):yuv2Jpeg() fail", __FUNCTION__);
2adfa429 3866
5506cebf 3867 m_resizeBuf = resizeBufInfo;
2adfa429 3868
5506cebf 3869 res = subParms->streamOps->enqueue_buffer(subParms->streamOps, frameTimeStamp, &(subParms->svcBufHandle[subParms->svcBufIndex]));
be494d19 3870
5506cebf
SK		 3871 ALOGV("DEBUG(%s): streamthread[%d] enqueue_buffer index(%d) to svc done res(%d)",
3872 __FUNCTION__, selfThread->m_index, subParms->svcBufIndex, res);
3873 if (res == 0) {
3874 subParms->svcBufStatus[subParms->svcBufIndex] = ON_SERVICE;
3875 subParms->numSvcBufsInHal--;
3876 }
3877 else {
3878 subParms->svcBufStatus[subParms->svcBufIndex] = ON_HAL;
3879 }
86646da4 3880
5506cebf
SK		 3881 while (subParms->numSvcBufsInHal <= subParms->minUndequedBuffer)
3882 {
3883 bool found = false;
3884 int checkingIndex = 0;
86646da4 3885
5506cebf
SK		 3886 ALOGV("DEBUG(%s): jpeg currentBuf#(%d)", __FUNCTION__ , subParms->numSvcBufsInHal);
3887
3888 res = subParms->streamOps->dequeue_buffer(subParms->streamOps, &buf);
3889 if (res != NO_ERROR || buf == NULL) {
3890 ALOGV("DEBUG(%s): jpeg stream(%d) dequeue_buffer fail res(%d)",__FUNCTION__ , selfThread->m_index, res);
3891 break;
3892 }
3893 const private_handle_t *priv_handle = reinterpret_cast<const private_handle_t *>(*buf);
3894 subParms->numSvcBufsInHal ++;
3895 ALOGV("DEBUG(%s): jpeg got buf(%x) numBufInHal(%d) version(%d), numFds(%d), numInts(%d)", __FUNCTION__, (uint32_t)(*buf),
3896 subParms->numSvcBufsInHal, ((native_handle_t*)(*buf))->version, ((native_handle_t*)(*buf))->numFds, ((native_handle_t*)(*buf))->numInts);
3897
3898
3899 for (checkingIndex = 0; checkingIndex < subParms->numSvcBuffers ; checkingIndex++) {
3900 if (priv_handle->fd == subParms->svcBuffers[checkingIndex].fd.extFd[0] ) {
3901 found = true;
3902 break;
86646da4 3903 }
5506cebf
SK		 3904 }
3905 ALOGV("DEBUG(%s): jpeg dequeueed_buffer found index(%d)", __FUNCTION__, found);
be494d19 3906
5506cebf
SK		 3907 if (!found) {
3908 break;
3909 }
3910
3911 subParms->svcBufIndex = checkingIndex;
3912 if (subParms->svcBufStatus[subParms->svcBufIndex] == ON_SERVICE) {
3913 subParms->svcBufStatus[subParms->svcBufIndex] = ON_HAL;
3914 }
3915 else {
3916 ALOGV("DEBUG(%s): jpeg bufstatus abnormal [%d] status = %d", __FUNCTION__,
3917 subParms->svcBufIndex, subParms->svcBufStatus[subParms->svcBufIndex]);
3918 }
3919 }
3920 return 0;
3921}
86646da4 3922
5506cebf
SK		 3923int ExynosCameraHWInterface2::m_recordCreator(StreamThread *selfThread, ExynosBuffer *srcImageBuf, nsecs_t frameTimeStamp)
3924{
3925 stream_parameters_t *selfStreamParms = &(selfThread->m_parameters);
3926 substream_parameters_t *subParms = &m_subStreams[STREAM_ID_RECORD];
3927 status_t res;
3928 ExynosRect jpegRect;
3929 bool found = false;
3930 int cropX, cropY, cropW, cropH = 0;
3931 buffer_handle_t * buf = NULL;
86646da4 3932
5506cebf
SK		 3933 ALOGV("DEBUG(%s): index(%d)",__FUNCTION__, subParms->svcBufIndex);
3934 for (int i = 0 ; subParms->numSvcBuffers ; i++) {
3935 if (subParms->svcBufStatus[subParms->svcBufIndex] == ON_HAL) {
3936 found = true;
3937 break;
3938 }
3939 subParms->svcBufIndex++;
3940 if (subParms->svcBufIndex >= subParms->numSvcBuffers)
3941 subParms->svcBufIndex = 0;
3942 }
3943 if (!found) {
3944 ALOGE("(%s): cannot find free svc buffer", __FUNCTION__);
3945 subParms->svcBufIndex++;
3946 return 1;
3947 }
86646da4 3948
5506cebf
SK		 3949 if (m_exynosVideoCSC) {
3950 int videoW = subParms->width, videoH = subParms->height;
3951 int cropX, cropY, cropW, cropH = 0;
3952 int previewW = selfStreamParms->width, previewH = selfStreamParms->height;
3953 m_getRatioSize(previewW, previewH,
3954 videoW, videoH,
3955 &cropX, &cropY,
3956 &cropW, &cropH,
3957 0);
86646da4 3958
5506cebf
SK		 3959 ALOGV("DEBUG(%s):cropX = %d, cropY = %d, cropW = %d, cropH = %d",
3960 __FUNCTION__, cropX, cropY, cropW, cropH);
86646da4 3961
5506cebf
SK		 3962 csc_set_src_format(m_exynosVideoCSC,
3963 previewW, previewH,
3964 cropX, cropY, cropW, cropH,
3965 selfStreamParms->format,
3966 0);
86646da4 3967
5506cebf
SK		 3968 csc_set_dst_format(m_exynosVideoCSC,
3969 videoW, videoH,
3970 0, 0, videoW, videoH,
3971 subParms->format,
3972 1);
86646da4 3973
5506cebf
SK		 3974 csc_set_src_buffer(m_exynosVideoCSC,
3975 (void **)&srcImageBuf->fd.fd);
86646da4 3976
5506cebf
SK		 3977 csc_set_dst_buffer(m_exynosVideoCSC,
3978 (void **)(&(subParms->svcBuffers[subParms->svcBufIndex].fd.fd)));
3979
3980 if (csc_convert(m_exynosVideoCSC) != 0) {
3981 ALOGE("ERR(%s):csc_convert() fail", __FUNCTION__);
3982 }
3983 else {
3984 ALOGV("(%s):csc_convert() SUCCESS", __FUNCTION__);
86646da4 3985 }
5506cebf
SK		 3986 }
3987 else {
3988 ALOGE("ERR(%s):m_exynosVideoCSC == NULL", __FUNCTION__);
3989 }
86646da4 3990
5506cebf 3991 res = subParms->streamOps->enqueue_buffer(subParms->streamOps, frameTimeStamp, &(subParms->svcBufHandle[subParms->svcBufIndex]));
86646da4 3992
5506cebf
SK		 3993 ALOGV("DEBUG(%s): streamthread[%d] enqueue_buffer index(%d) to svc done res(%d)",
3994 __FUNCTION__, selfThread->m_index, subParms->svcBufIndex, res);
3995 if (res == 0) {
3996 subParms->svcBufStatus[subParms->svcBufIndex] = ON_SERVICE;
3997 subParms->numSvcBufsInHal--;
3998 }
3999 else {
4000 subParms->svcBufStatus[subParms->svcBufIndex] = ON_HAL;
4001 }
86646da4 4002
5506cebf
SK		 4003 while (subParms->numSvcBufsInHal <= subParms->minUndequedBuffer)
4004 {
4005 bool found = false;
4006 int checkingIndex = 0;
86646da4 4007
5506cebf
SK		 4008 ALOGV("DEBUG(%s): record currentBuf#(%d)", __FUNCTION__ , subParms->numSvcBufsInHal);
4009
4010 res = subParms->streamOps->dequeue_buffer(subParms->streamOps, &buf);
4011 if (res != NO_ERROR || buf == NULL) {
4012 ALOGV("DEBUG(%s): record stream(%d) dequeue_buffer fail res(%d)",__FUNCTION__ , selfThread->m_index, res);
4013 break;
4014 }
4015 const private_handle_t *priv_handle = reinterpret_cast<const private_handle_t *>(*buf);
4016 subParms->numSvcBufsInHal ++;
4017 ALOGV("DEBUG(%s): record got buf(%x) numBufInHal(%d) version(%d), numFds(%d), numInts(%d)", __FUNCTION__, (uint32_t)(*buf),
4018 subParms->numSvcBufsInHal, ((native_handle_t*)(*buf))->version, ((native_handle_t*)(*buf))->numFds, ((native_handle_t*)(*buf))->numInts);
4019
4020 for (checkingIndex = 0; checkingIndex < subParms->numSvcBuffers ; checkingIndex++) {
4021 if (priv_handle->fd == subParms->svcBuffers[checkingIndex].fd.extFd[0] ) {
4022 found = true;
4023 break;
86646da4 4024 }
13d8c7b4 4025 }
5506cebf 4026 ALOGV("DEBUG(%s): record dequeueed_buffer found(%d) index = %d", __FUNCTION__, found, checkingIndex);
86646da4 4027
5506cebf
SK		 4028 if (!found) {
4029 break;
4030 }
86646da4 4031
5506cebf
SK		 4032 subParms->svcBufIndex = checkingIndex;
4033 if (subParms->svcBufStatus[subParms->svcBufIndex] == ON_SERVICE) {
4034 subParms->svcBufStatus[subParms->svcBufIndex] = ON_HAL;
4035 }
4036 else {
4037 ALOGV("DEBUG(%s): record bufstatus abnormal [%d] status = %d", __FUNCTION__,
4038 subParms->svcBufIndex, subParms->svcBufStatus[subParms->svcBufIndex]);
4039 }
4040 }
4041 return 0;
86646da4
SK		 4042}
4043
5506cebf 4044int ExynosCameraHWInterface2::m_prvcbCreator(StreamThread *selfThread, ExynosBuffer *srcImageBuf, nsecs_t frameTimeStamp)
86646da4 4045{
5506cebf
SK		 4046 stream_parameters_t *selfStreamParms = &(selfThread->m_parameters);
4047 substream_parameters_t *subParms = &m_subStreams[STREAM_ID_PRVCB];
4048 status_t res;
4049 bool found = false;
4050 int cropX, cropY, cropW, cropH = 0;
4051 buffer_handle_t * buf = NULL;
86646da4 4052
5506cebf
SK		 4053 ALOGV("DEBUG(%s): index(%d)",__FUNCTION__, subParms->svcBufIndex);
4054 for (int i = 0 ; subParms->numSvcBuffers ; i++) {
4055 if (subParms->svcBufStatus[subParms->svcBufIndex] == ON_HAL) {
4056 found = true;
4057 break;
4058 }
4059 subParms->svcBufIndex++;
4060 if (subParms->svcBufIndex >= subParms->numSvcBuffers)
4061 subParms->svcBufIndex = 0;
4062 }
4063 if (!found) {
4064 ALOGE("(%s): cannot find free svc buffer", __FUNCTION__);
4065 subParms->svcBufIndex++;
4066 return 1;
4067 }
86646da4 4068
5506cebf
SK		 4069 if (subParms->format == HAL_PIXEL_FORMAT_YCrCb_420_SP) {
4070 if (m_exynosVideoCSC) {
4071 int previewCbW = subParms->width, previewCbH = subParms->height;
4072 int cropX, cropY, cropW, cropH = 0;
4073 int previewW = selfStreamParms->width, previewH = selfStreamParms->height;
4074 m_getRatioSize(previewW, previewH,
4075 previewCbW, previewCbH,
4076 &cropX, &cropY,
4077 &cropW, &cropH,
4078 0);
86646da4 4079
5506cebf
SK		 4080 ALOGV("DEBUG(%s):cropX = %d, cropY = %d, cropW = %d, cropH = %d",
4081 __FUNCTION__, cropX, cropY, cropW, cropH);
4082 csc_set_src_format(m_exynosVideoCSC,
4083 previewW, previewH,
4084 cropX, cropY, cropW, cropH,
4085 selfStreamParms->format,
4086 0);
86646da4 4087
5506cebf
SK		 4088 csc_set_dst_format(m_exynosVideoCSC,
4089 previewCbW, previewCbH,
4090 0, 0, previewCbW, previewCbH,
4091 subParms->internalFormat,
4092 1);
86646da4 4093
5506cebf
SK		 4094 csc_set_src_buffer(m_exynosVideoCSC,
4095 (void **)&srcImageBuf->fd.fd);
4096
4097 csc_set_dst_buffer(m_exynosVideoCSC,
4098 (void **)(&(m_previewCbBuf.fd.fd)));
4099
4100 if (csc_convert(m_exynosVideoCSC) != 0) {
4101 ALOGE("ERR(%s):previewcb csc_convert() fail", __FUNCTION__);
4102 }
4103 else {
4104 ALOGV("(%s):previewcb csc_convert() SUCCESS", __FUNCTION__);
4105 }
4106 if (previewCbW == ALIGN(previewCbW, 16)) {
4107 memcpy(subParms->svcBuffers[subParms->svcBufIndex].virt.extP[0],
4108 m_previewCbBuf.virt.extP[0], previewCbW * previewCbH);
4109 memcpy(subParms->svcBuffers[subParms->svcBufIndex].virt.extP[0] + previewCbW * previewCbH,
4110 m_previewCbBuf.virt.extP[1], previewCbW * previewCbH / 2 );
4111 }
4112 else {
4113 // TODO : copy line by line ?
4114 }
4115 }
4116 else {
4117 ALOGE("ERR(%s):m_exynosVideoCSC == NULL", __FUNCTION__);
4118 }
86646da4 4119 }
5506cebf
SK		 4120 else if (subParms->format == HAL_PIXEL_FORMAT_YV12) {
4121 int previewCbW = subParms->width, previewCbH = subParms->height;
4122 int stride = ALIGN(previewCbW, 16);
0d220b42 4123 int c_stride = ALIGN(stride / 2, 16);
5506cebf
SK		 4124 memcpy(subParms->svcBuffers[subParms->svcBufIndex].virt.extP[0],
4125 srcImageBuf->virt.extP[0], stride * previewCbH);
4126 memcpy(subParms->svcBuffers[subParms->svcBufIndex].virt.extP[0] + stride * previewCbH,
4127 srcImageBuf->virt.extP[1], c_stride * previewCbH / 2 );
4128 memcpy(subParms->svcBuffers[subParms->svcBufIndex].virt.extP[0] + (stride * previewCbH) + (c_stride * previewCbH / 2),
4129 srcImageBuf->virt.extP[2], c_stride * previewCbH / 2 );
4130 }
4131 res = subParms->streamOps->enqueue_buffer(subParms->streamOps, frameTimeStamp, &(subParms->svcBufHandle[subParms->svcBufIndex]));
4132
4133 ALOGV("DEBUG(%s): streamthread[%d] enqueue_buffer index(%d) to svc done res(%d)",
4134 __FUNCTION__, selfThread->m_index, subParms->svcBufIndex, res);
4135 if (res == 0) {
4136 subParms->svcBufStatus[subParms->svcBufIndex] = ON_SERVICE;
4137 subParms->numSvcBufsInHal--;
4138 }
4139 else {
4140 subParms->svcBufStatus[subParms->svcBufIndex] = ON_HAL;
86646da4
SK		 4141 }
4142
5506cebf
SK		 4143 while (subParms->numSvcBufsInHal <= subParms->minUndequedBuffer)
4144 {
4145 bool found = false;
4146 int checkingIndex = 0;
86646da4 4147
5506cebf 4148 ALOGV("DEBUG(%s): prvcb currentBuf#(%d)", __FUNCTION__ , subParms->numSvcBufsInHal);
86646da4 4149
5506cebf
SK		 4150 res = subParms->streamOps->dequeue_buffer(subParms->streamOps, &buf);
4151 if (res != NO_ERROR || buf == NULL) {
4152 ALOGV("DEBUG(%s): prvcb stream(%d) dequeue_buffer fail res(%d)",__FUNCTION__ , selfThread->m_index, res);
4153 break;
4154 }
4155 const private_handle_t *priv_handle = reinterpret_cast<const private_handle_t *>(*buf);
4156 subParms->numSvcBufsInHal ++;
4157 ALOGV("DEBUG(%s): prvcb got buf(%x) numBufInHal(%d) version(%d), numFds(%d), numInts(%d)", __FUNCTION__, (uint32_t)(*buf),
4158 subParms->numSvcBufsInHal, ((native_handle_t*)(*buf))->version, ((native_handle_t*)(*buf))->numFds, ((native_handle_t*)(*buf))->numInts);
86646da4 4159
86646da4 4160
5506cebf
SK		 4161 for (checkingIndex = 0; checkingIndex < subParms->numSvcBuffers ; checkingIndex++) {
4162 if (priv_handle->fd == subParms->svcBuffers[checkingIndex].fd.extFd[0] ) {
4163 found = true;
4164 break;
4165 }
4166 }
4167 ALOGV("DEBUG(%s): prvcb dequeueed_buffer found(%d) index = %d", __FUNCTION__, found, checkingIndex);
4168
4169 if (!found) {
4170 break;
4171 }
4172
4173 subParms->svcBufIndex = checkingIndex;
4174 if (subParms->svcBufStatus[subParms->svcBufIndex] == ON_SERVICE) {
4175 subParms->svcBufStatus[subParms->svcBufIndex] = ON_HAL;
4176 }
4177 else {
4178 ALOGV("DEBUG(%s): prvcb bufstatus abnormal [%d] status = %d", __FUNCTION__,
4179 subParms->svcBufIndex, subParms->svcBufStatus[subParms->svcBufIndex]);
4180 }
4181 }
4182 return 0;
c15a6b00
JS		 4183}
4184
2d5e6ec2
SK		 4185bool ExynosCameraHWInterface2::m_checkThumbnailSize(int w, int h)
4186{
4187 int sizeOfSupportList;
4188
4189 //REAR Camera
4190 if(this->getCameraId() == 0) {
4191 sizeOfSupportList = sizeof(SUPPORT_THUMBNAIL_REAR_SIZE) / (sizeof(int)*2);
4192
4193 for(int i = 0; i < sizeOfSupportList; i++) {
4194 if((SUPPORT_THUMBNAIL_REAR_SIZE[i][0] == w) &&(SUPPORT_THUMBNAIL_REAR_SIZE[i][1] == h))
4195 return true;
4196 }
4197
4198 }
4199 else {
4200 sizeOfSupportList = sizeof(SUPPORT_THUMBNAIL_FRONT_SIZE) / (sizeof(int)*2);
4201
4202 for(int i = 0; i < sizeOfSupportList; i++) {
4203 if((SUPPORT_THUMBNAIL_FRONT_SIZE[i][0] == w) &&(SUPPORT_THUMBNAIL_FRONT_SIZE[i][1] == h))
4204 return true;
4205 }
4206 }
4207
4208 return false;
4209}
13d8c7b4
SK		 4210bool ExynosCameraHWInterface2::yuv2Jpeg(ExynosBuffer *yuvBuf,
4211 ExynosBuffer *jpegBuf,
4212 ExynosRect *rect)
4213{
4214 unsigned char *addr;
4215
4216 ExynosJpegEncoderForCamera jpegEnc;
4217 bool ret = false;
4218 int res = 0;
4219
4220 unsigned int *yuvSize = yuvBuf->size.extS;
4221
4222 if (jpegEnc.create()) {
9dd63e1f 4223 ALOGE("ERR(%s):jpegEnc.create() fail", __FUNCTION__);
13d8c7b4
SK		 4224 goto jpeg_encode_done;
4225 }
4226
4227 if (jpegEnc.setQuality(100)) {
9dd63e1f 4228 ALOGE("ERR(%s):jpegEnc.setQuality() fail", __FUNCTION__);
13d8c7b4
SK		 4229 goto jpeg_encode_done;
4230 }
4231
4232 if (jpegEnc.setSize(rect->w, rect->h)) {
9dd63e1f 4233 ALOGE("ERR(%s):jpegEnc.setSize() fail", __FUNCTION__);
13d8c7b4
SK		 4234 goto jpeg_encode_done;
4235 }
4236 ALOGV("%s : width = %d , height = %d\n", __FUNCTION__, rect->w, rect->h);
4237
4238 if (jpegEnc.setColorFormat(rect->colorFormat)) {
9dd63e1f 4239 ALOGE("ERR(%s):jpegEnc.setColorFormat() fail", __FUNCTION__);
13d8c7b4
SK		 4240 goto jpeg_encode_done;
4241 }
13d8c7b4
SK		 4242
4243 if (jpegEnc.setJpegFormat(V4L2_PIX_FMT_JPEG_422)) {
9dd63e1f 4244 ALOGE("ERR(%s):jpegEnc.setJpegFormat() fail", __FUNCTION__);
13d8c7b4
SK		 4245 goto jpeg_encode_done;
4246 }
13d8c7b4 4247
2d5e6ec2
SK		 4248 if((m_jpegMetadata.ctl.jpeg.thumbnailSize[0] != 0) && (m_jpegMetadata.ctl.jpeg.thumbnailSize[1] != 0)) {
4249 mExifInfo.enableThumb = true;
4250 if(!m_checkThumbnailSize(m_jpegMetadata.ctl.jpeg.thumbnailSize[0], m_jpegMetadata.ctl.jpeg.thumbnailSize[1])) {
4251 //default value
4252 m_thumbNailW = SUPPORT_THUMBNAIL_REAR_SIZE[0][0];
4253 m_thumbNailH = SUPPORT_THUMBNAIL_REAR_SIZE[0][1];
4254 } else {
4255 m_thumbNailW = m_jpegMetadata.ctl.jpeg.thumbnailSize[0];
4256 m_thumbNailH = m_jpegMetadata.ctl.jpeg.thumbnailSize[1];
4257 }
4258
4259 ALOGV("(%s) m_thumbNailW = %d, m_thumbNailH = %d", __FUNCTION__, m_thumbNailW, m_thumbNailH);
4260
4261 } else {
4262 mExifInfo.enableThumb = false;
4263 }
eed7ed1b 4264
2d5e6ec2
SK		 4265 if (jpegEnc.setThumbnailSize(m_thumbNailW, m_thumbNailH)) {
4266 ALOGE("ERR(%s):jpegEnc.setThumbnailSize(%d, %d) fail", __FUNCTION__, m_thumbNailH, m_thumbNailH);
eed7ed1b
SK		 4267 goto jpeg_encode_done;
4268 }
4269
2d5e6ec2 4270 ALOGV("(%s):jpegEnc.setThumbnailSize(%d, %d) ", __FUNCTION__, m_thumbNailW, m_thumbNailW);
eed7ed1b
SK		 4271 if (jpegEnc.setThumbnailQuality(50)) {
4272 ALOGE("ERR(%s):jpegEnc.setThumbnailQuality fail", __FUNCTION__);
4273 goto jpeg_encode_done;
4274 }
13d8c7b4 4275
eed7ed1b 4276 m_setExifChangedAttribute(&mExifInfo, rect, &m_jpegMetadata);
9dd63e1f 4277 ALOGV("DEBUG(%s):calling jpegEnc.setInBuf() yuvSize(%d)", __FUNCTION__, *yuvSize);
eed7ed1b 4278 if (jpegEnc.setInBuf((int *)&(yuvBuf->fd.fd), &(yuvBuf->virt.p), (int *)yuvSize)) {
9dd63e1f 4279 ALOGE("ERR(%s):jpegEnc.setInBuf() fail", __FUNCTION__);
13d8c7b4
SK		 4280 goto jpeg_encode_done;
4281 }
eed7ed1b 4282 if (jpegEnc.setOutBuf(jpegBuf->fd.fd, jpegBuf->virt.p, jpegBuf->size.extS[0] + jpegBuf->size.extS[1] + jpegBuf->size.extS[2])) {
9dd63e1f 4283 ALOGE("ERR(%s):jpegEnc.setOutBuf() fail", __FUNCTION__);
13d8c7b4
SK		 4284 goto jpeg_encode_done;
4285 }
13d8c7b4
SK		 4286
4287 if (jpegEnc.updateConfig()) {
9dd63e1f 4288 ALOGE("ERR(%s):jpegEnc.updateConfig() fail", __FUNCTION__);
13d8c7b4
SK		 4289 goto jpeg_encode_done;
4290 }
4291
eed7ed1b 4292 if (res = jpegEnc.encode((int *)&jpegBuf->size.s, &mExifInfo)) {
9dd63e1f 4293 ALOGE("ERR(%s):jpegEnc.encode() fail ret(%d)", __FUNCTION__, res);
13d8c7b4
SK		 4294 goto jpeg_encode_done;
4295 }
4296
4297 ret = true;
4298
4299jpeg_encode_done:
4300
4301 if (jpegEnc.flagCreate() == true)
4302 jpegEnc.destroy();
4303
4304 return ret;
4305}
4306
e117f756
YJ		 4307void ExynosCameraHWInterface2::OnPrecaptureMeteringTriggerStart(int id)
4308{
4309 m_ctlInfo.flash.m_precaptureTriggerId = id;
4310 if ((m_ctlInfo.flash.i_flashMode >= AA_AEMODE_ON_AUTO_FLASH) && (m_cameraId == 0)) {
4311 // flash is required
4312 switch (m_ctlInfo.flash.m_flashCnt) {
4313 case IS_FLASH_STATE_AUTO_DONE:
4314 // Flash capture sequence, AF flash was executed before
4315 break;
4316 default:
4317 // Full flash sequence
4318 m_ctlInfo.flash.m_flashCnt = IS_FLASH_STATE_ON;
4319 m_ctlInfo.flash.m_flashEnableFlg = true;
4320 }
4321 } else {
4322 // Apply AE & AWB lock
4323 ALOGV("[PreCap] Flash OFF mode ");
4324 m_ctlInfo.flash.m_flashEnableFlg = false;
4325 m_ctlInfo.flash.m_flashCnt = IS_FLASH_STATE_NONE;
4326 m_ctlInfo.ae.m_aeCnt = IS_COMMAND_EXECUTION;
4327 m_ctlInfo.awb.m_awbCnt = IS_COMMAND_EXECUTION;
4328 }
4329 ALOGV("[PreCap] OnPrecaptureMeteringTriggerStart (ID %d) (flag : %d) (cnt : %d)", id, m_ctlInfo.flash.m_flashEnableFlg, m_ctlInfo.flash.m_flashCnt);
4330}
8e2c2fdb
SK		 4331void ExynosCameraHWInterface2::OnAfTriggerStart(int id)
4332{
4333 m_afPendingTriggerId = id;
7d0efb59 4334 m_afModeWaitingCnt = 6;
8e2c2fdb 4335}
13d8c7b4 4336
0f26b20f
SK		 4337void ExynosCameraHWInterface2::OnAfTrigger(int id)
4338{
8e2c2fdb 4339 m_afTriggerId = id;
6f19b6cf 4340
0f26b20f
SK		 4341 switch (m_afMode) {
4342 case AA_AFMODE_AUTO:
4343 case AA_AFMODE_MACRO:
8e2c2fdb 4344 case AA_AFMODE_OFF:
caea49e6
YJ		 4345 ALOGE("[AF] OnAfTrigger - AUTO,MACRO,OFF (Mode %d) ", m_afMode);
4346 // If flash is enable, Flash operation is executed before triggering AF
4347 if ((m_ctlInfo.flash.i_flashMode >= AA_AEMODE_ON_AUTO_FLASH)
e117f756 4348 && (m_ctlInfo.flash.m_flashEnableFlg == false)
caea49e6 4349 && (m_cameraId == 0)) {
e117f756
YJ		 4350 ALOGE("[Flash] AF Flash start with Mode (%d)", m_afMode);
4351 m_ctlInfo.flash.m_flashEnableFlg = true;
4352 m_ctlInfo.flash.m_flashCnt = IS_FLASH_STATE_ON;
caea49e6 4353 m_ctlInfo.flash.m_flashDecisionResult = false;
e117f756 4354 m_ctlInfo.flash.m_afFlashDoneFlg = true;
caea49e6 4355 }
0f26b20f
SK		 4356 OnAfTriggerAutoMacro(id);
4357 break;
4358 case AA_AFMODE_CONTINUOUS_VIDEO:
caea49e6 4359 ALOGE("[AF] OnAfTrigger - AA_AFMODE_CONTINUOUS_VIDEO (Mode %d) ", m_afMode);
0f26b20f
SK		 4360 OnAfTriggerCAFVideo(id);
4361 break;
4362 case AA_AFMODE_CONTINUOUS_PICTURE:
caea49e6 4363 ALOGE("[AF] OnAfTrigger - AA_AFMODE_CONTINUOUS_PICTURE (Mode %d) ", m_afMode);
0f26b20f
SK		 4364 OnAfTriggerCAFPicture(id);
4365 break;
8e2c2fdb 4366
0f26b20f
SK		 4367 default:
4368 break;
4369 }
4370}
4371
4372void ExynosCameraHWInterface2::OnAfTriggerAutoMacro(int id)
4373{
4374 int nextState = NO_TRANSITION;
0f26b20f
SK		 4375
4376 switch (m_afState) {
4377 case HAL_AFSTATE_INACTIVE:
4378 nextState = HAL_AFSTATE_NEEDS_COMMAND;
4379 m_IsAfTriggerRequired = true;
4380 break;
4381 case HAL_AFSTATE_NEEDS_COMMAND:
4382 nextState = NO_TRANSITION;
4383 break;
4384 case HAL_AFSTATE_STARTED:
4385 nextState = NO_TRANSITION;
4386 break;
4387 case HAL_AFSTATE_SCANNING:
4388 nextState = NO_TRANSITION;
4389 break;
4390 case HAL_AFSTATE_LOCKED:
4391 nextState = HAL_AFSTATE_NEEDS_COMMAND;
4392 m_IsAfTriggerRequired = true;
4393 break;
4394 case HAL_AFSTATE_FAILED:
4395 nextState = HAL_AFSTATE_NEEDS_COMMAND;
4396 m_IsAfTriggerRequired = true;
4397 break;
4398 default:
4399 break;
4400 }
4401 ALOGV("(%s): State (%d) -> (%d)", __FUNCTION__, m_afState, nextState);
4402 if (nextState != NO_TRANSITION)
4403 m_afState = nextState;
4404}
4405
4406void ExynosCameraHWInterface2::OnAfTriggerCAFPicture(int id)
4407{
4408 int nextState = NO_TRANSITION;
0f26b20f
SK		 4409
4410 switch (m_afState) {
4411 case HAL_AFSTATE_INACTIVE:
4412 nextState = HAL_AFSTATE_FAILED;
4413 SetAfStateForService(ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED);
4414 break;
4415 case HAL_AFSTATE_NEEDS_COMMAND:
4416 // not used
4417 break;
4418 case HAL_AFSTATE_STARTED:
4419 nextState = HAL_AFSTATE_NEEDS_DETERMINATION;
36c106c9 4420 m_AfHwStateFailed = false;
caea49e6
YJ		 4421 // If flash is enable, Flash operation is executed before triggering AF
4422 if ((m_ctlInfo.flash.i_flashMode >= AA_AEMODE_ON_AUTO_FLASH)
e117f756 4423 && (m_ctlInfo.flash.m_flashEnableFlg == false)
caea49e6
YJ		 4424 && (m_cameraId == 0)) {
4425 ALOGE("[AF Flash] AF Flash start with Mode (%d) state (%d) id (%d)", m_afMode, m_afState, id);
e117f756
YJ		 4426 m_ctlInfo.flash.m_flashEnableFlg = true;
4427 m_ctlInfo.flash.m_flashCnt = IS_FLASH_STATE_ON;
caea49e6 4428 m_ctlInfo.flash.m_flashDecisionResult = false;
e117f756 4429 m_ctlInfo.flash.m_afFlashDoneFlg = true;
caea49e6 4430 }
0f26b20f
SK		 4431 break;
4432 case HAL_AFSTATE_SCANNING:
4433 nextState = HAL_AFSTATE_NEEDS_DETERMINATION;
36c106c9 4434 m_AfHwStateFailed = false;
caea49e6
YJ		 4435 // If flash is enable, Flash operation is executed before triggering AF
4436 if ((m_ctlInfo.flash.i_flashMode >= AA_AEMODE_ON_AUTO_FLASH)
e117f756 4437 && (m_ctlInfo.flash.m_flashEnableFlg == false)
caea49e6
YJ		 4438 && (m_cameraId == 0)) {
4439 ALOGE("[AF Flash] AF Flash start with Mode (%d) state (%d) id (%d)", m_afMode, m_afState, id);
e117f756
YJ		 4440 m_ctlInfo.flash.m_flashEnableFlg = true;
4441 m_ctlInfo.flash.m_flashCnt = IS_FLASH_STATE_ON;
caea49e6 4442 m_ctlInfo.flash.m_flashDecisionResult = false;
e117f756 4443 m_ctlInfo.flash.m_afFlashDoneFlg = true;
caea49e6 4444 }
0f26b20f
SK		 4445 break;
4446 case HAL_AFSTATE_NEEDS_DETERMINATION:
4447 nextState = NO_TRANSITION;
4448 break;
4449 case HAL_AFSTATE_PASSIVE_FOCUSED:
4450 m_IsAfLockRequired = true;
36c106c9 4451 if (m_AfHwStateFailed) {
caea49e6 4452 ALOGE("(%s): [CAF] LAST : fail", __FUNCTION__);
36c106c9
SK		 4453 SetAfStateForService(ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED);
4454 nextState = HAL_AFSTATE_FAILED;
4455 }
4456 else {
caea49e6 4457 ALOGV("(%s): [CAF] LAST : success", __FUNCTION__);
36c106c9
SK		 4458 SetAfStateForService(ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED);
4459 nextState = HAL_AFSTATE_LOCKED;
4460 }
4461 m_AfHwStateFailed = false;
0f26b20f
SK		 4462 break;
4463 case HAL_AFSTATE_LOCKED:
4464 nextState = NO_TRANSITION;
4465 break;
4466 case HAL_AFSTATE_FAILED:
4467 nextState = NO_TRANSITION;
4468 break;
4469 default:
4470 break;
4471 }
4472 ALOGV("(%s): State (%d) -> (%d)", __FUNCTION__, m_afState, nextState);
4473 if (nextState != NO_TRANSITION)
4474 m_afState = nextState;
4475}
4476
4477
4478void ExynosCameraHWInterface2::OnAfTriggerCAFVideo(int id)
4479{
4480 int nextState = NO_TRANSITION;
0f26b20f
SK		 4481
4482 switch (m_afState) {
4483 case HAL_AFSTATE_INACTIVE:
4484 nextState = HAL_AFSTATE_FAILED;
4485 SetAfStateForService(ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED);
4486 break;
4487 case HAL_AFSTATE_NEEDS_COMMAND:
4488 // not used
4489 break;
4490 case HAL_AFSTATE_STARTED:
4491 m_IsAfLockRequired = true;
4492 nextState = HAL_AFSTATE_FAILED;
4493 SetAfStateForService(ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED);
4494 break;
4495 case HAL_AFSTATE_SCANNING:
4496 m_IsAfLockRequired = true;
4497 nextState = HAL_AFSTATE_FAILED;
4498 SetAfStateForService(ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED);
4499 break;
4500 case HAL_AFSTATE_NEEDS_DETERMINATION:
4501 // not used
4502 break;
4503 case HAL_AFSTATE_PASSIVE_FOCUSED:
4504 m_IsAfLockRequired = true;
4505 SetAfStateForService(ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED);
4506 nextState = HAL_AFSTATE_LOCKED;
4507 break;
4508 case HAL_AFSTATE_LOCKED:
4509 nextState = NO_TRANSITION;
4510 break;
4511 case HAL_AFSTATE_FAILED:
4512 nextState = NO_TRANSITION;
4513 break;
4514 default:
4515 break;
4516 }
4517 ALOGV("(%s): State (%d) -> (%d)", __FUNCTION__, m_afState, nextState);
4518 if (nextState != NO_TRANSITION)
4519 m_afState = nextState;
4520}
4521
e117f756
YJ		 4522void ExynosCameraHWInterface2::OnPrecaptureMeteringNotification()
4523{
4524 if (m_ctlInfo.flash.m_precaptureTriggerId > 0) {
4525 if (m_ctlInfo.flash.m_flashEnableFlg) {
4526 // flash case
4527 switch (m_ctlInfo.flash.m_flashCnt) {
4528 case IS_FLASH_STATE_AUTO_DONE:
4529 m_notifyCb(CAMERA2_MSG_AUTOEXPOSURE,
4530 ANDROID_CONTROL_AE_STATE_LOCKED,
4531 m_ctlInfo.flash.m_precaptureTriggerId, 0, m_callbackCookie);
4532 m_notifyCb(CAMERA2_MSG_AUTOWB,
4533 ANDROID_CONTROL_AWB_STATE_LOCKED,
4534 m_ctlInfo.flash.m_precaptureTriggerId, 0, m_callbackCookie);
4535 m_ctlInfo.flash.m_precaptureTriggerId = 0;
4536 break;
4537 default:
4538 if (m_ctlInfo.flash.m_flashCnt >= IS_FLASH_STATE_CAPTURE) {
4539 ALOGE("(%s) INVALID flash state count. (%d)", (int)m_ctlInfo.flash.m_flashCnt);
4540 m_ctlInfo.flash.m_flashCnt = IS_FLASH_STATE_AUTO_DONE;
4541 m_notifyCb(CAMERA2_MSG_AUTOEXPOSURE,
4542 ANDROID_CONTROL_AE_STATE_LOCKED,
4543 m_ctlInfo.flash.m_precaptureTriggerId, 0, m_callbackCookie);
4544 m_notifyCb(CAMERA2_MSG_AUTOWB,
4545 ANDROID_CONTROL_AWB_STATE_LOCKED,
4546 m_ctlInfo.flash.m_precaptureTriggerId, 0, m_callbackCookie);
4547 m_ctlInfo.flash.m_precaptureTriggerId = 0;
4548 } else {
4549 m_notifyCb(CAMERA2_MSG_AUTOEXPOSURE,
4550 ANDROID_CONTROL_AE_STATE_PRECAPTURE,
4551 m_ctlInfo.flash.m_precaptureTriggerId, 0, m_callbackCookie);
4552 m_notifyCb(CAMERA2_MSG_AUTOWB,
4553 ANDROID_CONTROL_AWB_STATE_CONVERGED,
4554 m_ctlInfo.flash.m_precaptureTriggerId, 0, m_callbackCookie);
4555 }
4556 }
4557 } else {
4558 // non-flash case
4559 // AE
4560 switch (m_ctlInfo.ae.m_aeCnt) {
4561 case IS_COMMAND_EXECUTION:
4562 m_notifyCb(CAMERA2_MSG_AUTOEXPOSURE,
4563 ANDROID_CONTROL_AE_STATE_PRECAPTURE,
4564 m_ctlInfo.flash.m_precaptureTriggerId, 0, m_callbackCookie);
4565 ALOGE("[PreCap] OnPrecaptureMeteringNotification (ID %d) CAMERA2_MSG_AUTOEXPOSURE, ANDROID_CONTROL_AE_STATE_PRECAPTURE", m_ctlInfo.flash.m_precaptureTriggerId);
4566 break;
4567 case IS_COMMAND_NONE:
4568 case IS_COMMAND_CLEAR:
4569 m_notifyCb(CAMERA2_MSG_AUTOEXPOSURE,
4570 ANDROID_CONTROL_AE_STATE_LOCKED,
4571 m_ctlInfo.flash.m_precaptureTriggerId, 0, m_callbackCookie);
4572 ALOGE("[PreCap] OnPrecaptureMeteringNotification (ID %d) CAMERA2_MSG_AUTOEXPOSURE, ANDROID_CONTROL_AE_STATE_LOCKED", m_ctlInfo.flash.m_precaptureTriggerId);
4573 m_ctlInfo.flash.m_precaptureTriggerId = 0;
4574 break;
4575 }
4576 // AWB
4577 switch (m_ctlInfo.awb.m_awbCnt) {
4578 case IS_COMMAND_EXECUTION:
4579 m_notifyCb(CAMERA2_MSG_AUTOWB,
4580 ANDROID_CONTROL_AWB_STATE_CONVERGED,
4581 m_ctlInfo.flash.m_precaptureTriggerId, 0, m_callbackCookie);
4582 break;
4583 case IS_COMMAND_NONE:
4584 case IS_COMMAND_CLEAR:
4585 m_notifyCb(CAMERA2_MSG_AUTOWB,
4586 ANDROID_CONTROL_AWB_STATE_LOCKED,
4587 m_ctlInfo.flash.m_precaptureTriggerId, 0, m_callbackCookie);
4588 break;
4589 }
4590 }
4591 }
4592}
4593
0f26b20f
SK		 4594void ExynosCameraHWInterface2::OnAfNotification(enum aa_afstate noti)
4595{
4596 switch (m_afMode) {
4597 case AA_AFMODE_AUTO:
4598 case AA_AFMODE_MACRO:
4599 OnAfNotificationAutoMacro(noti);
4600 break;
4601 case AA_AFMODE_CONTINUOUS_VIDEO:
4602 OnAfNotificationCAFVideo(noti);
4603 break;
4604 case AA_AFMODE_CONTINUOUS_PICTURE:
4605 OnAfNotificationCAFPicture(noti);
4606 break;
4607 case AA_AFMODE_OFF:
4608 default:
4609 break;
4610 }
4611}
4612
4613void ExynosCameraHWInterface2::OnAfNotificationAutoMacro(enum aa_afstate noti)
4614{
4615 int nextState = NO_TRANSITION;
4616 bool bWrongTransition = false;
4617
4618 if (m_afState == HAL_AFSTATE_INACTIVE || m_afState == HAL_AFSTATE_NEEDS_COMMAND) {
4619 switch (noti) {
4620 case AA_AFSTATE_INACTIVE:
4621 case AA_AFSTATE_ACTIVE_SCAN:
4622 case AA_AFSTATE_AF_ACQUIRED_FOCUS:
4623 case AA_AFSTATE_AF_FAILED_FOCUS:
4624 default:
4625 nextState = NO_TRANSITION;
4626 break;
4627 }
4628 }
4629 else if (m_afState == HAL_AFSTATE_STARTED) {
4630 switch (noti) {
4631 case AA_AFSTATE_INACTIVE:
4632 nextState = NO_TRANSITION;
4633 break;
4634 case AA_AFSTATE_ACTIVE_SCAN:
4635 nextState = HAL_AFSTATE_SCANNING;
4636 SetAfStateForService(ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN);
4637 break;
4638 case AA_AFSTATE_AF_ACQUIRED_FOCUS:
4639 nextState = NO_TRANSITION;
4640 break;
4641 case AA_AFSTATE_AF_FAILED_FOCUS:
4642 nextState = NO_TRANSITION;
4643 break;
4644 default:
4645 bWrongTransition = true;
4646 break;
4647 }
4648 }
4649 else if (m_afState == HAL_AFSTATE_SCANNING) {
4650 switch (noti) {
4651 case AA_AFSTATE_INACTIVE:
4652 bWrongTransition = true;
4653 break;
4654 case AA_AFSTATE_ACTIVE_SCAN:
4655 nextState = NO_TRANSITION;
4656 break;
4657 case AA_AFSTATE_AF_ACQUIRED_FOCUS:
9a710a45 4658 // If Flash mode is enable, after AF execute pre-capture metering
e117f756
YJ		 4659 if (m_ctlInfo.flash.m_flashEnableFlg && m_ctlInfo.flash.m_afFlashDoneFlg) {
4660 switch (m_ctlInfo.flash.m_flashCnt) {
4661 case IS_FLASH_STATE_ON_DONE:
4662 m_ctlInfo.flash.m_flashCnt = IS_FLASH_STATE_AUTO_AE_AWB_LOCK;
4663 break;
4664 case IS_FLASH_STATE_AUTO_DONE:
9a710a45
YJ		 4665 nextState = HAL_AFSTATE_LOCKED;
4666 SetAfStateForService(ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED);
e117f756
YJ		 4667 break;
4668 default:
9a710a45
YJ		 4669 nextState = NO_TRANSITION;
4670 }
4671 } else {
4672 nextState = HAL_AFSTATE_LOCKED;
4673 SetAfStateForService(ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED);
4674 }
0f26b20f
SK		 4675 break;
4676 case AA_AFSTATE_AF_FAILED_FOCUS:
9a710a45 4677 // If Flash mode is enable, after AF execute pre-capture metering
e117f756
YJ		 4678 if (m_ctlInfo.flash.m_flashEnableFlg && m_ctlInfo.flash.m_afFlashDoneFlg) {
4679 switch (m_ctlInfo.flash.m_flashCnt) {
4680 case IS_FLASH_STATE_ON_DONE:
4681 m_ctlInfo.flash.m_flashCnt = IS_FLASH_STATE_AUTO_AE_AWB_LOCK;
4682 break;
4683 case IS_FLASH_STATE_AUTO_DONE:
9a710a45
YJ		 4684 nextState = HAL_AFSTATE_FAILED;
4685 SetAfStateForService(ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED);
e117f756
YJ		 4686 break;
4687 default:
9a710a45
YJ		 4688 nextState = NO_TRANSITION;
4689 }
4690 } else {
4691 nextState = HAL_AFSTATE_FAILED;
4692 SetAfStateForService(ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED);
4693 }
0f26b20f
SK		 4694 break;
4695 default:
4696 bWrongTransition = true;
4697 break;
4698 }
4699 }
4700 else if (m_afState == HAL_AFSTATE_LOCKED) {
4701 switch (noti) {
4702 case AA_AFSTATE_INACTIVE:
4703 case AA_AFSTATE_ACTIVE_SCAN:
4704 bWrongTransition = true;
4705 break;
4706 case AA_AFSTATE_AF_ACQUIRED_FOCUS:
6f19b6cf 4707 // Flash off if flash mode is available.
e117f756
YJ		 4708 if (m_ctlInfo.flash.m_flashEnableFlg && m_ctlInfo.flash.m_afFlashDoneFlg)
4709 m_ctlInfo.flash.m_flashCnt = IS_FLASH_STATE_AUTO_OFF;
0f26b20f
SK		 4710 nextState = NO_TRANSITION;
4711 break;
4712 case AA_AFSTATE_AF_FAILED_FOCUS:
4713 default:
4714 bWrongTransition = true;
4715 break;
4716 }
4717 }
4718 else if (m_afState == HAL_AFSTATE_FAILED) {
4719 switch (noti) {
4720 case AA_AFSTATE_INACTIVE:
4721 case AA_AFSTATE_ACTIVE_SCAN:
4722 case AA_AFSTATE_AF_ACQUIRED_FOCUS:
4723 bWrongTransition = true;
4724 break;
4725 case AA_AFSTATE_AF_FAILED_FOCUS:
6f19b6cf 4726 // Flash off if flash mode is available.
e117f756
YJ		 4727 if (m_ctlInfo.flash.m_flashEnableFlg && m_ctlInfo.flash.m_afFlashDoneFlg)
4728 m_ctlInfo.flash.m_flashCnt = IS_FLASH_STATE_AUTO_OFF;
0f26b20f
SK		 4729 nextState = NO_TRANSITION;
4730 break;
4731 default:
4732 bWrongTransition = true;
4733 break;
4734 }
4735 }
4736 if (bWrongTransition) {
4737 ALOGV("(%s): Wrong Transition state(%d) noti(%d)", __FUNCTION__, m_afState, noti);
4738 return;
4739 }
4740 ALOGV("(%s): State (%d) -> (%d) by (%d)", __FUNCTION__, m_afState, nextState, noti);
4741 if (nextState != NO_TRANSITION)
4742 m_afState = nextState;
4743}
4744
4745void ExynosCameraHWInterface2::OnAfNotificationCAFPicture(enum aa_afstate noti)
4746{
4747 int nextState = NO_TRANSITION;
4748 bool bWrongTransition = false;
4749
4750 if (m_afState == HAL_AFSTATE_INACTIVE) {
4751 switch (noti) {
4752 case AA_AFSTATE_INACTIVE:
4753 case AA_AFSTATE_ACTIVE_SCAN:
4754 case AA_AFSTATE_AF_ACQUIRED_FOCUS:
4755 case AA_AFSTATE_AF_FAILED_FOCUS:
4756 default:
4757 nextState = NO_TRANSITION;
4758 break;
4759 }
4760 }
4761 else if (m_afState == HAL_AFSTATE_STARTED) {
4762 switch (noti) {
4763 case AA_AFSTATE_INACTIVE:
4764 nextState = NO_TRANSITION;
4765 break;
4766 case AA_AFSTATE_ACTIVE_SCAN:
4767 nextState = HAL_AFSTATE_SCANNING;
4768 SetAfStateForService(ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN);
4769 break;
4770 case AA_AFSTATE_AF_ACQUIRED_FOCUS:
4771 nextState = HAL_AFSTATE_PASSIVE_FOCUSED;
4772 SetAfStateForService(ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED);
4773 break;
4774 case AA_AFSTATE_AF_FAILED_FOCUS:
cd13bb78
SK		 4775 //nextState = HAL_AFSTATE_FAILED;
4776 //SetAfStateForService(ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED);
4777 nextState = NO_TRANSITION;
0f26b20f
SK		 4778 break;
4779 default:
4780 bWrongTransition = true;
4781 break;
4782 }
4783 }
4784 else if (m_afState == HAL_AFSTATE_SCANNING) {
4785 switch (noti) {
4786 case AA_AFSTATE_INACTIVE:
36c106c9 4787 nextState = NO_TRANSITION;
0f26b20f
SK		 4788 break;
4789 case AA_AFSTATE_ACTIVE_SCAN:
4790 nextState = NO_TRANSITION;
36c106c9 4791 m_AfHwStateFailed = false;
0f26b20f
SK		 4792 break;
4793 case AA_AFSTATE_AF_ACQUIRED_FOCUS:
4794 nextState = HAL_AFSTATE_PASSIVE_FOCUSED;
36c106c9 4795 m_AfHwStateFailed = false;
0f26b20f
SK		 4796 SetAfStateForService(ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED);
4797 break;
4798 case AA_AFSTATE_AF_FAILED_FOCUS:
36c106c9
SK		 4799 nextState = HAL_AFSTATE_PASSIVE_FOCUSED;
4800 m_AfHwStateFailed = true;
4801 SetAfStateForService(ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED);
0f26b20f
SK		 4802 break;
4803 default:
4804 bWrongTransition = true;
4805 break;
4806 }
4807 }
4808 else if (m_afState == HAL_AFSTATE_PASSIVE_FOCUSED) {
4809 switch (noti) {
4810 case AA_AFSTATE_INACTIVE:
36c106c9 4811 nextState = NO_TRANSITION;
0f26b20f
SK		 4812 break;
4813 case AA_AFSTATE_ACTIVE_SCAN:
4814 nextState = HAL_AFSTATE_SCANNING;
36c106c9 4815 m_AfHwStateFailed = false;
0f26b20f
SK		 4816 SetAfStateForService(ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN);
4817 break;
4818 case AA_AFSTATE_AF_ACQUIRED_FOCUS:
4819 nextState = NO_TRANSITION;
36c106c9 4820 m_AfHwStateFailed = false;
caea49e6 4821 // Flash off if flash mode is available.
e117f756 4822 if (m_ctlInfo.flash.m_flashEnableFlg && m_ctlInfo.flash.m_afFlashDoneFlg) {
caea49e6 4823 ALOGD("[AF Flash] Off with Mode (%d) state (%d) noti (%d)", m_afMode, m_afState, (int)noti);
e117f756 4824 m_ctlInfo.flash.m_flashCnt = IS_FLASH_STATE_AUTO_OFF;
caea49e6 4825 }
0f26b20f
SK		 4826 break;
4827 case AA_AFSTATE_AF_FAILED_FOCUS:
36c106c9
SK		 4828 nextState = NO_TRANSITION;
4829 m_AfHwStateFailed = true;
caea49e6 4830 // Flash off if flash mode is available.
e117f756 4831 if (m_ctlInfo.flash.m_flashEnableFlg && m_ctlInfo.flash.m_afFlashDoneFlg) {
caea49e6 4832 ALOGD("[AF Flash] Off with Mode (%d) state (%d) noti (%d)", m_afMode, m_afState, (int)noti);
e117f756 4833 m_ctlInfo.flash.m_flashCnt = IS_FLASH_STATE_AUTO_OFF;
caea49e6 4834 }
0f26b20f
SK		 4835 break;
4836 default:
4837 bWrongTransition = true;
4838 break;
4839 }
4840 }
4841 else if (m_afState == HAL_AFSTATE_NEEDS_DETERMINATION) {
4842 switch (noti) {
4843 case AA_AFSTATE_INACTIVE:
36c106c9 4844 nextState = NO_TRANSITION;
0f26b20f
SK		 4845 break;
4846 case AA_AFSTATE_ACTIVE_SCAN:
4847 nextState = NO_TRANSITION;
4848 break;
4849 case AA_AFSTATE_AF_ACQUIRED_FOCUS:
caea49e6 4850 // If Flash mode is enable, after AF execute pre-capture metering
e117f756
YJ		 4851 if (m_ctlInfo.flash.m_flashEnableFlg && m_ctlInfo.flash.m_afFlashDoneFlg) {
4852 ALOGD("[AF Flash] AUTO start with Mode (%d) state (%d) noti (%d)", m_afMode, m_afState, (int)noti);
4853 switch (m_ctlInfo.flash.m_flashCnt) {
4854 case IS_FLASH_STATE_ON_DONE:
4855 m_ctlInfo.flash.m_flashCnt = IS_FLASH_STATE_AUTO_AE_AWB_LOCK;
4856 break;
4857 case IS_FLASH_STATE_AUTO_DONE:
caea49e6
YJ		 4858 m_IsAfLockRequired = true;
4859 nextState = HAL_AFSTATE_LOCKED;
4860 SetAfStateForService(ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED);
e117f756
YJ		 4861 break;
4862 default:
caea49e6
YJ		 4863 nextState = NO_TRANSITION;
4864 }
4865 } else {
4866 m_IsAfLockRequired = true;
4867 nextState = HAL_AFSTATE_LOCKED;
4868 SetAfStateForService(ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED);
4869 }
0f26b20f
SK		 4870 break;
4871 case AA_AFSTATE_AF_FAILED_FOCUS:
caea49e6 4872 // If Flash mode is enable, after AF execute pre-capture metering
e117f756
YJ		 4873 if (m_ctlInfo.flash.m_flashEnableFlg && m_ctlInfo.flash.m_afFlashDoneFlg) {
4874 ALOGD("[AF Flash] AUTO start with Mode (%d) state (%d) noti (%d)", m_afMode, m_afState, (int)noti);
4875 switch (m_ctlInfo.flash.m_flashCnt) {
4876 case IS_FLASH_STATE_ON_DONE:
4877 m_ctlInfo.flash.m_flashCnt = IS_FLASH_STATE_AUTO_AE_AWB_LOCK;
4878 break;
4879 case IS_FLASH_STATE_AUTO_DONE:
caea49e6
YJ		 4880 m_IsAfLockRequired = true;
4881 nextState = HAL_AFSTATE_FAILED;
4882 SetAfStateForService(ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED);
e117f756
YJ		 4883 break;
4884 default:
caea49e6
YJ		 4885 nextState = NO_TRANSITION;
4886 }
4887 } else {
4888 m_IsAfLockRequired = true;
4889 nextState = HAL_AFSTATE_FAILED;
4890 SetAfStateForService(ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED);
4891 }
0f26b20f
SK		 4892 break;
4893 default:
4894 bWrongTransition = true;
4895 break;
4896 }
4897 }
4898 else if (m_afState == HAL_AFSTATE_LOCKED) {
4899 switch (noti) {
4900 case AA_AFSTATE_INACTIVE:
4901 nextState = NO_TRANSITION;
4902 break;
4903 case AA_AFSTATE_ACTIVE_SCAN:
4904 bWrongTransition = true;
4905 break;
4906 case AA_AFSTATE_AF_ACQUIRED_FOCUS:
4907 nextState = NO_TRANSITION;
caea49e6 4908 // Flash off if flash mode is available.
e117f756 4909 if (m_ctlInfo.flash.m_flashEnableFlg && m_ctlInfo.flash.m_afFlashDoneFlg) {
caea49e6 4910 ALOGD("[AF Flash] Off with Mode (%d) state (%d) noti (%d)", m_afMode, m_afState, (int)noti);
e117f756 4911 m_ctlInfo.flash.m_flashCnt = IS_FLASH_STATE_AUTO_OFF;
caea49e6 4912 }
0f26b20f
SK		 4913 break;
4914 case AA_AFSTATE_AF_FAILED_FOCUS:
4915 default:
4916 bWrongTransition = true;
4917 break;
4918 }
4919 }
4920 else if (m_afState == HAL_AFSTATE_FAILED) {
4921 switch (noti) {
4922 case AA_AFSTATE_INACTIVE:
36c106c9
SK		 4923 bWrongTransition = true;
4924 break;
0f26b20f 4925 case AA_AFSTATE_ACTIVE_SCAN:
36c106c9
SK		 4926 nextState = HAL_AFSTATE_SCANNING;
4927 break;
0f26b20f
SK		 4928 case AA_AFSTATE_AF_ACQUIRED_FOCUS:
4929 bWrongTransition = true;
4930 break;
4931 case AA_AFSTATE_AF_FAILED_FOCUS:
caea49e6 4932 // Flash off if flash mode is available.
e117f756 4933 if (m_ctlInfo.flash.m_flashEnableFlg && m_ctlInfo.flash.m_afFlashDoneFlg) {
caea49e6 4934 ALOGD("[AF Flash] Off with Mode (%d) state (%d) noti (%d)", m_afMode, m_afState, (int)noti);
e117f756 4935 m_ctlInfo.flash.m_flashCnt = IS_FLASH_STATE_AUTO_OFF;
caea49e6 4936 }
0f26b20f
SK		 4937 nextState = NO_TRANSITION;
4938 break;
4939 default:
4940 bWrongTransition = true;
4941 break;
4942 }
4943 }
4944 if (bWrongTransition) {
4945 ALOGV("(%s): Wrong Transition state(%d) noti(%d)", __FUNCTION__, m_afState, noti);
4946 return;
4947 }
4948 ALOGV("(%s): State (%d) -> (%d) by (%d)", __FUNCTION__, m_afState, nextState, noti);
4949 if (nextState != NO_TRANSITION)
4950 m_afState = nextState;
4951}
4952
4953void ExynosCameraHWInterface2::OnAfNotificationCAFVideo(enum aa_afstate noti)
4954{
4955 int nextState = NO_TRANSITION;
4956 bool bWrongTransition = false;
4957
4958 if (m_afState == HAL_AFSTATE_INACTIVE) {
4959 switch (noti) {
4960 case AA_AFSTATE_INACTIVE:
4961 case AA_AFSTATE_ACTIVE_SCAN:
4962 case AA_AFSTATE_AF_ACQUIRED_FOCUS:
4963 case AA_AFSTATE_AF_FAILED_FOCUS:
4964 default:
4965 nextState = NO_TRANSITION;
4966 break;
4967 }
4968 }
4969 else if (m_afState == HAL_AFSTATE_STARTED) {
4970 switch (noti) {
4971 case AA_AFSTATE_INACTIVE:
4972 nextState = NO_TRANSITION;
4973 break;
4974 case AA_AFSTATE_ACTIVE_SCAN:
4975 nextState = HAL_AFSTATE_SCANNING;
4976 SetAfStateForService(ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN);
4977 break;
4978 case AA_AFSTATE_AF_ACQUIRED_FOCUS:
4979 nextState = HAL_AFSTATE_PASSIVE_FOCUSED;
4980 SetAfStateForService(ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED);
4981 break;
4982 case AA_AFSTATE_AF_FAILED_FOCUS:
4983 nextState = HAL_AFSTATE_FAILED;
4984 SetAfStateForService(ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED);
4985 break;
4986 default:
4987 bWrongTransition = true;
4988 break;
4989 }
4990 }
4991 else if (m_afState == HAL_AFSTATE_SCANNING) {
4992 switch (noti) {
4993 case AA_AFSTATE_INACTIVE:
4994 bWrongTransition = true;
4995 break;
4996 case AA_AFSTATE_ACTIVE_SCAN:
4997 nextState = NO_TRANSITION;
4998 break;
4999 case AA_AFSTATE_AF_ACQUIRED_FOCUS:
5000 nextState = HAL_AFSTATE_PASSIVE_FOCUSED;
5001 SetAfStateForService(ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED);
5002 break;
5003 case AA_AFSTATE_AF_FAILED_FOCUS:
5004 nextState = NO_TRANSITION;
5005 break;
5006 default:
5007 bWrongTransition = true;
5008 break;
5009 }
5010 }
5011 else if (m_afState == HAL_AFSTATE_PASSIVE_FOCUSED) {
5012 switch (noti) {
5013 case AA_AFSTATE_INACTIVE:
5014 bWrongTransition = true;
5015 break;
5016 case AA_AFSTATE_ACTIVE_SCAN:
5017 nextState = HAL_AFSTATE_SCANNING;
5018 SetAfStateForService(ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN);
5019 break;
5020 case AA_AFSTATE_AF_ACQUIRED_FOCUS:
5021 nextState = NO_TRANSITION;
5022 break;
5023 case AA_AFSTATE_AF_FAILED_FOCUS:
5024 nextState = HAL_AFSTATE_FAILED;
5025 SetAfStateForService(ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED);
8e2c2fdb 5026 // TODO : needs NO_TRANSITION ?
0f26b20f
SK		 5027 break;
5028 default:
5029 bWrongTransition = true;
5030 break;
5031 }
5032 }
5033 else if (m_afState == HAL_AFSTATE_NEEDS_DETERMINATION) {
5034 switch (noti) {
5035 case AA_AFSTATE_INACTIVE:
5036 bWrongTransition = true;
5037 break;
5038 case AA_AFSTATE_ACTIVE_SCAN:
5039 nextState = NO_TRANSITION;
5040 break;
5041 case AA_AFSTATE_AF_ACQUIRED_FOCUS:
5042 m_IsAfLockRequired = true;
5043 nextState = HAL_AFSTATE_LOCKED;
5044 SetAfStateForService(ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED);
5045 break;
5046 case AA_AFSTATE_AF_FAILED_FOCUS:
5047 nextState = HAL_AFSTATE_FAILED;
5048 SetAfStateForService(ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED);
5049 break;
5050 default:
5051 bWrongTransition = true;
5052 break;
5053 }
5054 }
5055 else if (m_afState == HAL_AFSTATE_LOCKED) {
5056 switch (noti) {
5057 case AA_AFSTATE_INACTIVE:
5058 nextState = NO_TRANSITION;
5059 break;
5060 case AA_AFSTATE_ACTIVE_SCAN:
5061 bWrongTransition = true;
5062 break;
5063 case AA_AFSTATE_AF_ACQUIRED_FOCUS:
5064 nextState = NO_TRANSITION;
5065 break;
5066 case AA_AFSTATE_AF_FAILED_FOCUS:
5067 default:
5068 bWrongTransition = true;
5069 break;
5070 }
5071 }
5072 else if (m_afState == HAL_AFSTATE_FAILED) {
5073 switch (noti) {
5074 case AA_AFSTATE_INACTIVE:
5075 case AA_AFSTATE_ACTIVE_SCAN:
5076 case AA_AFSTATE_AF_ACQUIRED_FOCUS:
5077 bWrongTransition = true;
5078 break;
5079 case AA_AFSTATE_AF_FAILED_FOCUS:
5080 nextState = NO_TRANSITION;
5081 break;
5082 default:
5083 bWrongTransition = true;
5084 break;
5085 }
5086 }
5087 if (bWrongTransition) {
5088 ALOGV("(%s): Wrong Transition state(%d) noti(%d)", __FUNCTION__, m_afState, noti);
5089 return;
5090 }
5091 ALOGV("(%s): State (%d) -> (%d) by (%d)", __FUNCTION__, m_afState, nextState, noti);
5092 if (nextState != NO_TRANSITION)
5093 m_afState = nextState;
5094}
5095
5096void ExynosCameraHWInterface2::OnAfCancel(int id)
5097{
8e2c2fdb
SK		 5098 m_afTriggerId = id;
5099
0f26b20f
SK		 5100 switch (m_afMode) {
5101 case AA_AFMODE_AUTO:
5102 case AA_AFMODE_MACRO:
8e2c2fdb 5103 case AA_AFMODE_OFF:
0f26b20f
SK		 5104 OnAfCancelAutoMacro(id);
5105 break;
5106 case AA_AFMODE_CONTINUOUS_VIDEO:
5107 OnAfCancelCAFVideo(id);
5108 break;
5109 case AA_AFMODE_CONTINUOUS_PICTURE:
5110 OnAfCancelCAFPicture(id);
5111 break;
0f26b20f
SK		 5112 default:
5113 break;
5114 }
5115}
5116
5117void ExynosCameraHWInterface2::OnAfCancelAutoMacro(int id)
5118{
5119 int nextState = NO_TRANSITION;
5120 m_afTriggerId = id;
5121
e117f756
YJ		 5122 if (m_ctlInfo.flash.m_flashEnableFlg && m_ctlInfo.flash.m_afFlashDoneFlg) {
5123 m_ctlInfo.flash.m_flashCnt = IS_FLASH_STATE_AUTO_OFF;
6f19b6cf 5124 }
0f26b20f
SK		 5125 switch (m_afState) {
5126 case HAL_AFSTATE_INACTIVE:
5127 nextState = NO_TRANSITION;
cd13bb78 5128 SetAfStateForService(ANDROID_CONTROL_AF_STATE_INACTIVE);
0f26b20f
SK		 5129 break;
5130 case HAL_AFSTATE_NEEDS_COMMAND:
5131 case HAL_AFSTATE_STARTED:
5132 case HAL_AFSTATE_SCANNING:
5133 case HAL_AFSTATE_LOCKED:
5134 case HAL_AFSTATE_FAILED:
5135 SetAfMode(AA_AFMODE_OFF);
5136 SetAfStateForService(ANDROID_CONTROL_AF_STATE_INACTIVE);
5137 nextState = HAL_AFSTATE_INACTIVE;
5138 break;
5139 default:
5140 break;
5141 }
5142 ALOGV("(%s): State (%d) -> (%d)", __FUNCTION__, m_afState, nextState);
5143 if (nextState != NO_TRANSITION)
5144 m_afState = nextState;
5145}
5146
5147void ExynosCameraHWInterface2::OnAfCancelCAFPicture(int id)
5148{
5149 int nextState = NO_TRANSITION;
5150 m_afTriggerId = id;
5151
5152 switch (m_afState) {
5153 case HAL_AFSTATE_INACTIVE:
5154 nextState = NO_TRANSITION;
5155 break;
5156 case HAL_AFSTATE_NEEDS_COMMAND:
5157 case HAL_AFSTATE_STARTED:
5158 case HAL_AFSTATE_SCANNING:
5159 case HAL_AFSTATE_LOCKED:
5160 case HAL_AFSTATE_FAILED:
5161 case HAL_AFSTATE_NEEDS_DETERMINATION:
5162 case HAL_AFSTATE_PASSIVE_FOCUSED:
5163 SetAfMode(AA_AFMODE_OFF);
5164 SetAfStateForService(ANDROID_CONTROL_AF_STATE_INACTIVE);
5165 SetAfMode(AA_AFMODE_CONTINUOUS_PICTURE);
5166 nextState = HAL_AFSTATE_INACTIVE;
5167 break;
5168 default:
5169 break;
5170 }
5171 ALOGV("(%s): State (%d) -> (%d)", __FUNCTION__, m_afState, nextState);
5172 if (nextState != NO_TRANSITION)
5173 m_afState = nextState;
5174}
5175
5176void ExynosCameraHWInterface2::OnAfCancelCAFVideo(int id)
5177{
5178 int nextState = NO_TRANSITION;
5179 m_afTriggerId = id;
5180
5181 switch (m_afState) {
5182 case HAL_AFSTATE_INACTIVE:
5183 nextState = NO_TRANSITION;
5184 break;
5185 case HAL_AFSTATE_NEEDS_COMMAND:
5186 case HAL_AFSTATE_STARTED:
5187 case HAL_AFSTATE_SCANNING:
5188 case HAL_AFSTATE_LOCKED:
5189 case HAL_AFSTATE_FAILED:
5190 case HAL_AFSTATE_NEEDS_DETERMINATION:
5191 case HAL_AFSTATE_PASSIVE_FOCUSED:
5192 SetAfMode(AA_AFMODE_OFF);
5193 SetAfStateForService(ANDROID_CONTROL_AF_STATE_INACTIVE);
5194 SetAfMode(AA_AFMODE_CONTINUOUS_VIDEO);
5195 nextState = HAL_AFSTATE_INACTIVE;
5196 break;
5197 default:
5198 break;
5199 }
5200 ALOGV("(%s): State (%d) -> (%d)", __FUNCTION__, m_afState, nextState);
5201 if (nextState != NO_TRANSITION)
5202 m_afState = nextState;
5203}
5204
5205void ExynosCameraHWInterface2::SetAfStateForService(int newState)
5206{
8e2c2fdb
SK		 5207 if (m_serviceAfState != newState || newState == 0)
5208 m_notifyCb(CAMERA2_MSG_AUTOFOCUS, newState, m_afTriggerId, 0, m_callbackCookie);
0f26b20f 5209 m_serviceAfState = newState;
0f26b20f
SK		 5210}
5211
5212int ExynosCameraHWInterface2::GetAfStateForService()
5213{
5214 return m_serviceAfState;
5215}
5216
5217void ExynosCameraHWInterface2::SetAfMode(enum aa_afmode afMode)
5218{
5219 if (m_afMode != afMode) {
5220 if (m_IsAfModeUpdateRequired) {
5221 m_afMode2 = afMode;
5222 ALOGV("(%s): pending(%d) and new(%d)", __FUNCTION__, m_afMode, afMode);
5223 }
5224 else {
5225 ALOGV("(%s): current(%d) new(%d)", __FUNCTION__, m_afMode, afMode);
5226 m_IsAfModeUpdateRequired = true;
5227 m_afMode = afMode;
cd13bb78
SK		 5228 if (m_afModeWaitingCnt != 0) {
5229 m_afModeWaitingCnt = 0;
7d0efb59 5230 m_afState = HAL_AFSTATE_INACTIVE;
cd13bb78
SK		 5231 OnAfTrigger(m_afPendingTriggerId);
5232 }
8e2c2fdb 5233 }
0f26b20f
SK		 5234 }
5235}
5236
eed7ed1b
SK		 5237void ExynosCameraHWInterface2::m_setExifFixedAttribute(void)
5238{
5239 char property[PROPERTY_VALUE_MAX];
5240
5241 //2 0th IFD TIFF Tags
1b8ef182 5242#if 0 // STOPSHIP TODO(aray): remove before launch, but for now don't leak product data
eed7ed1b
SK		 5243 //3 Maker
5244 property_get("ro.product.brand", property, EXIF_DEF_MAKER);
5245 strncpy((char *)mExifInfo.maker, property,
5246 sizeof(mExifInfo.maker) - 1);
5247 mExifInfo.maker[sizeof(mExifInfo.maker) - 1] = '\0';
5248 //3 Model
5249 property_get("ro.product.model", property, EXIF_DEF_MODEL);
5250 strncpy((char *)mExifInfo.model, property,
5251 sizeof(mExifInfo.model) - 1);
5252 mExifInfo.model[sizeof(mExifInfo.model) - 1] = '\0';
5253 //3 Software
5254 property_get("ro.build.id", property, EXIF_DEF_SOFTWARE);
5255 strncpy((char *)mExifInfo.software, property,
5256 sizeof(mExifInfo.software) - 1);
5257 mExifInfo.software[sizeof(mExifInfo.software) - 1] = '\0';
5a92f77a 5258#endif
eed7ed1b
SK		 5259
5260 //3 YCbCr Positioning
5261 mExifInfo.ycbcr_positioning = EXIF_DEF_YCBCR_POSITIONING;
5262
5263 //2 0th IFD Exif Private Tags
5264 //3 F Number
e00f6591 5265 mExifInfo.fnumber.num = (uint32_t)(m_camera2->m_curCameraInfo->fnumber * EXIF_DEF_FNUMBER_DEN);
eed7ed1b
SK		 5266 mExifInfo.fnumber.den = EXIF_DEF_FNUMBER_DEN;
5267 //3 Exposure Program
5268 mExifInfo.exposure_program = EXIF_DEF_EXPOSURE_PROGRAM;
5269 //3 Exif Version
5270 memcpy(mExifInfo.exif_version, EXIF_DEF_EXIF_VERSION, sizeof(mExifInfo.exif_version));
5271 //3 Aperture
e00f6591
SK		 5272 double av = APEX_FNUM_TO_APERTURE((double)mExifInfo.fnumber.num/mExifInfo.fnumber.den);
5273 mExifInfo.aperture.num = (uint32_t)(av*EXIF_DEF_APEX_DEN);
eed7ed1b
SK		 5274 mExifInfo.aperture.den = EXIF_DEF_APEX_DEN;
5275 //3 Maximum lens aperture
5276 mExifInfo.max_aperture.num = mExifInfo.aperture.num;
5277 mExifInfo.max_aperture.den = mExifInfo.aperture.den;
5278 //3 Lens Focal Length
e00f6591
SK		 5279 mExifInfo.focal_length.num = (uint32_t)(m_camera2->m_curCameraInfo->focalLength * 100);
5280
eed7ed1b
SK		 5281 mExifInfo.focal_length.den = EXIF_DEF_FOCAL_LEN_DEN;
5282 //3 User Comments
5283 strcpy((char *)mExifInfo.user_comment, EXIF_DEF_USERCOMMENTS);
5284 //3 Color Space information
5285 mExifInfo.color_space = EXIF_DEF_COLOR_SPACE;
5286 //3 Exposure Mode
5287 mExifInfo.exposure_mode = EXIF_DEF_EXPOSURE_MODE;
5288
5289 //2 0th IFD GPS Info Tags
5290 unsigned char gps_version[4] = { 0x02, 0x02, 0x00, 0x00 };
5291 memcpy(mExifInfo.gps_version_id, gps_version, sizeof(gps_version));
5292
5293 //2 1th IFD TIFF Tags
5294 mExifInfo.compression_scheme = EXIF_DEF_COMPRESSION;
5295 mExifInfo.x_resolution.num = EXIF_DEF_RESOLUTION_NUM;
5296 mExifInfo.x_resolution.den = EXIF_DEF_RESOLUTION_DEN;
5297 mExifInfo.y_resolution.num = EXIF_DEF_RESOLUTION_NUM;
5298 mExifInfo.y_resolution.den = EXIF_DEF_RESOLUTION_DEN;
5299 mExifInfo.resolution_unit = EXIF_DEF_RESOLUTION_UNIT;
5300}
5301
5302void ExynosCameraHWInterface2::m_setExifChangedAttribute(exif_attribute_t *exifInfo, ExynosRect *rect,
5303 camera2_shot *currentEntry)
5304{
5305 camera2_dm *dm = &(currentEntry->dm);
5306 camera2_ctl *ctl = &(currentEntry->ctl);
5307
5308 ALOGV("(%s): framecnt(%d) exp(%lld) iso(%d)", __FUNCTION__, ctl->request.frameCount, dm->sensor.exposureTime,dm->aa.isoValue );
5309 if (!ctl->request.frameCount)
5310 return;
5311 //2 0th IFD TIFF Tags
5312 //3 Width
5313 exifInfo->width = rect->w;
5314 //3 Height
5315 exifInfo->height = rect->h;
5316 //3 Orientation
5317 switch (ctl->jpeg.orientation) {
5318 case 90:
5319 exifInfo->orientation = EXIF_ORIENTATION_90;
5320 break;
5321 case 180:
5322 exifInfo->orientation = EXIF_ORIENTATION_180;
5323 break;
5324 case 270:
5325 exifInfo->orientation = EXIF_ORIENTATION_270;
5326 break;
5327 case 0:
5328 default:
5329 exifInfo->orientation = EXIF_ORIENTATION_UP;
5330 break;
5331 }
5332
5333 //3 Date time
5334 time_t rawtime;
5335 struct tm *timeinfo;
5336 time(&rawtime);
5337 timeinfo = localtime(&rawtime);
5338 strftime((char *)exifInfo->date_time, 20, "%Y:%m:%d %H:%M:%S", timeinfo);
5339
5340 //2 0th IFD Exif Private Tags
5341 //3 Exposure Time
5342 int shutterSpeed = (dm->sensor.exposureTime/1000);
5343
5344 if (shutterSpeed < 0) {
5345 shutterSpeed = 100;
5346 }
5347
5348 exifInfo->exposure_time.num = 1;
5349 // x us -> 1/x s */
5350 //exifInfo->exposure_time.den = (uint32_t)(1000000 / shutterSpeed);
5351 exifInfo->exposure_time.den = (uint32_t)((double)1000000 / shutterSpeed);
5352
5353 //3 ISO Speed Rating
5354 exifInfo->iso_speed_rating = dm->aa.isoValue;
5355
5356 uint32_t av, tv, bv, sv, ev;
5357 av = APEX_FNUM_TO_APERTURE((double)exifInfo->fnumber.num / exifInfo->fnumber.den);
5358 tv = APEX_EXPOSURE_TO_SHUTTER((double)exifInfo->exposure_time.num / exifInfo->exposure_time.den);
5359 sv = APEX_ISO_TO_FILMSENSITIVITY(exifInfo->iso_speed_rating);
5360 bv = av + tv - sv;
5361 ev = av + tv;
5362 //ALOGD("Shutter speed=%d us, iso=%d", shutterSpeed, exifInfo->iso_speed_rating);
5363 ALOGD("AV=%d, TV=%d, SV=%d", av, tv, sv);
5364
5365 //3 Shutter Speed
5366 exifInfo->shutter_speed.num = tv * EXIF_DEF_APEX_DEN;
5367 exifInfo->shutter_speed.den = EXIF_DEF_APEX_DEN;
5368 //3 Brightness
5369 exifInfo->brightness.num = bv*EXIF_DEF_APEX_DEN;
5370 exifInfo->brightness.den = EXIF_DEF_APEX_DEN;
5371 //3 Exposure Bias
5372 if (ctl->aa.sceneMode== AA_SCENE_MODE_BEACH||
5373 ctl->aa.sceneMode== AA_SCENE_MODE_SNOW) {
5374 exifInfo->exposure_bias.num = EXIF_DEF_APEX_DEN;
5375 exifInfo->exposure_bias.den = EXIF_DEF_APEX_DEN;
5376 } else {
5377 exifInfo->exposure_bias.num = 0;
5378 exifInfo->exposure_bias.den = 0;
5379 }
5380 //3 Metering Mode
5381 /*switch (m_curCameraInfo->metering) {
5382 case METERING_MODE_CENTER:
5383 exifInfo->metering_mode = EXIF_METERING_CENTER;
5384 break;
5385 case METERING_MODE_MATRIX:
5386 exifInfo->metering_mode = EXIF_METERING_MULTISPOT;
5387 break;
5388 case METERING_MODE_SPOT:
5389 exifInfo->metering_mode = EXIF_METERING_SPOT;
5390 break;
5391 case METERING_MODE_AVERAGE:
5392 default:
5393 exifInfo->metering_mode = EXIF_METERING_AVERAGE;
5394 break;
5395 }*/
5396 exifInfo->metering_mode = EXIF_METERING_CENTER;
5397
5398 //3 Flash
9257e29e
YJ		 5399 if (m_ctlInfo.flash.m_flashDecisionResult)
5400 exifInfo->flash = 1;
5401 else
5402 exifInfo->flash = EXIF_DEF_FLASH;
eed7ed1b
SK		 5403
5404 //3 White Balance
53f62ad9 5405 if (m_ctlInfo.awb.i_awbMode == AA_AWBMODE_WB_AUTO)
eed7ed1b
SK		 5406 exifInfo->white_balance = EXIF_WB_AUTO;
5407 else
5408 exifInfo->white_balance = EXIF_WB_MANUAL;
5409
5410 //3 Scene Capture Type
5411 switch (ctl->aa.sceneMode) {
5412 case AA_SCENE_MODE_PORTRAIT:
5413 exifInfo->scene_capture_type = EXIF_SCENE_PORTRAIT;
5414 break;
5415 case AA_SCENE_MODE_LANDSCAPE:
5416 exifInfo->scene_capture_type = EXIF_SCENE_LANDSCAPE;
5417 break;
5418 case AA_SCENE_MODE_NIGHT_PORTRAIT:
5419 exifInfo->scene_capture_type = EXIF_SCENE_NIGHT;
5420 break;
5421 default:
5422 exifInfo->scene_capture_type = EXIF_SCENE_STANDARD;
5423 break;
5424 }
5425
5426 //2 0th IFD GPS Info Tags
5427 if (ctl->jpeg.gpsCoordinates[0] != 0 && ctl->jpeg.gpsCoordinates[1] != 0) {
5428
5429 if (ctl->jpeg.gpsCoordinates[0] > 0)
5430 strcpy((char *)exifInfo->gps_latitude_ref, "N");
5431 else
5432 strcpy((char *)exifInfo->gps_latitude_ref, "S");
5433
5434 if (ctl->jpeg.gpsCoordinates[1] > 0)
5435 strcpy((char *)exifInfo->gps_longitude_ref, "E");
5436 else
5437 strcpy((char *)exifInfo->gps_longitude_ref, "W");
5438
5439 if (ctl->jpeg.gpsCoordinates[2] > 0)
5440 exifInfo->gps_altitude_ref = 0;
5441 else
5442 exifInfo->gps_altitude_ref = 1;
5443
5444 double latitude = fabs(ctl->jpeg.gpsCoordinates[0] / 10000.0);
5445 double longitude = fabs(ctl->jpeg.gpsCoordinates[1] / 10000.0);
5446 double altitude = fabs(ctl->jpeg.gpsCoordinates[2] / 100.0);
5447
5448 exifInfo->gps_latitude[0].num = (uint32_t)latitude;
5449 exifInfo->gps_latitude[0].den = 1;
5450 exifInfo->gps_latitude[1].num = (uint32_t)((latitude - exifInfo->gps_latitude[0].num) * 60);
5451 exifInfo->gps_latitude[1].den = 1;
5452 exifInfo->gps_latitude[2].num = (uint32_t)((((latitude - exifInfo->gps_latitude[0].num) * 60)
5453 - exifInfo->gps_latitude[1].num) * 60);
5454 exifInfo->gps_latitude[2].den = 1;
5455
5456 exifInfo->gps_longitude[0].num = (uint32_t)longitude;
5457 exifInfo->gps_longitude[0].den = 1;
5458 exifInfo->gps_longitude[1].num = (uint32_t)((longitude - exifInfo->gps_longitude[0].num) * 60);
5459 exifInfo->gps_longitude[1].den = 1;
5460 exifInfo->gps_longitude[2].num = (uint32_t)((((longitude - exifInfo->gps_longitude[0].num) * 60)
5461 - exifInfo->gps_longitude[1].num) * 60);
5462 exifInfo->gps_longitude[2].den = 1;
5463
5464 exifInfo->gps_altitude.num = (uint32_t)altitude;
5465 exifInfo->gps_altitude.den = 1;
5466
5467 struct tm tm_data;
5468 long timestamp;
5469 timestamp = (long)ctl->jpeg.gpsTimestamp;
5470 gmtime_r(&timestamp, &tm_data);
5471 exifInfo->gps_timestamp[0].num = tm_data.tm_hour;
5472 exifInfo->gps_timestamp[0].den = 1;
5473 exifInfo->gps_timestamp[1].num = tm_data.tm_min;
5474 exifInfo->gps_timestamp[1].den = 1;
5475 exifInfo->gps_timestamp[2].num = tm_data.tm_sec;
5476 exifInfo->gps_timestamp[2].den = 1;
5477 snprintf((char*)exifInfo->gps_datestamp, sizeof(exifInfo->gps_datestamp),
5478 "%04d:%02d:%02d", tm_data.tm_year + 1900, tm_data.tm_mon + 1, tm_data.tm_mday);
5479
5480 exifInfo->enableGps = true;
5481 } else {
5482 exifInfo->enableGps = false;
5483 }
5484
5485 //2 1th IFD TIFF Tags
5486 exifInfo->widthThumb = ctl->jpeg.thumbnailSize[0];
5487 exifInfo->heightThumb = ctl->jpeg.thumbnailSize[1];
5488}
5489
13d8c7b4
SK		 5490ExynosCameraHWInterface2::MainThread::~MainThread()
5491{
ad37861e 5492 ALOGV("(%s):", __FUNCTION__);
13d8c7b4
SK		 5493}
5494
5495void ExynosCameraHWInterface2::MainThread::release()
5496{
ad37861e 5497 ALOGV("(%s):", __func__);
13d8c7b4 5498 SetSignal(SIGNAL_THREAD_RELEASE);
13d8c7b4
SK		 5499}
5500
5501ExynosCameraHWInterface2::SensorThread::~SensorThread()
5502{
ad37861e 5503 ALOGV("(%s):", __FUNCTION__);
13d8c7b4
SK		 5504}
5505
5506void ExynosCameraHWInterface2::SensorThread::release()
5507{
ad37861e 5508 ALOGV("(%s):", __func__);
13d8c7b4 5509 SetSignal(SIGNAL_THREAD_RELEASE);
13d8c7b4
SK		 5510}
5511
13d8c7b4
SK		 5512ExynosCameraHWInterface2::StreamThread::~StreamThread()
5513{
ad37861e 5514 ALOGV("(%s):", __FUNCTION__);
13d8c7b4
SK		 5515}
5516
5517void ExynosCameraHWInterface2::StreamThread::setParameter(stream_parameters_t * new_parameters)
5518{
5519 ALOGV("DEBUG(%s):", __FUNCTION__);
5506cebf 5520 memcpy(&m_parameters, new_parameters, sizeof(stream_parameters_t));
c15a6b00
JS		 5521}
5522
13d8c7b4 5523void ExynosCameraHWInterface2::StreamThread::release()
c15a6b00 5524{
9dd63e1f 5525 ALOGV("(%s):", __func__);
13d8c7b4 5526 SetSignal(SIGNAL_THREAD_RELEASE);
13d8c7b4
SK		 5527}
5528
5529int ExynosCameraHWInterface2::StreamThread::findBufferIndex(void * bufAddr)
5530{
5531 int index;
5532 for (index = 0 ; index < m_parameters.numSvcBuffers ; index++) {
5533 if (m_parameters.svcBuffers[index].virt.extP[0] == bufAddr)
5534 return index;
5535 }
5536 return -1;
c15a6b00
JS		 5537}
5538
5506cebf
SK		 5539int ExynosCameraHWInterface2::StreamThread::findBufferIndex(buffer_handle_t * bufHandle)
5540{
5541 int index;
5542 for (index = 0 ; index < m_parameters.numSvcBuffers ; index++) {
5543 if (m_parameters.svcBufHandle[index] == *bufHandle)
5544 return index;
5545 }
5546 return -1;
5547}
5548
5549status_t ExynosCameraHWInterface2::StreamThread::attachSubStream(int stream_id, int priority)
9dd63e1f 5550{
5506cebf
SK		 5551 ALOGV("(%s): substream_id(%d)", __FUNCTION__, stream_id);
5552 int index, vacantIndex;
5553 bool vacancy = false;
5554
5555 for (index = 0 ; index < NUM_MAX_SUBSTREAM ; index++) {
5556 if (!vacancy && m_attachedSubStreams[index].streamId == -1) {
5557 vacancy = true;
5558 vacantIndex = index;
5559 } else if (m_attachedSubStreams[index].streamId == stream_id) {
5560 return BAD_VALUE;
5561 }
5562 }
5563 if (!vacancy)
5564 return NO_MEMORY;
5565 m_attachedSubStreams[vacantIndex].streamId = stream_id;
5566 m_attachedSubStreams[vacantIndex].priority = priority;
5567 m_numRegisteredStream++;
5568 return NO_ERROR;
9dd63e1f
SK		 5569}
5570
5506cebf 5571status_t ExynosCameraHWInterface2::StreamThread::detachSubStream(int stream_id)
74d78ebe 5572{
5506cebf
SK		 5573 ALOGV("(%s): substream_id(%d)", __FUNCTION__, stream_id);
5574 int index;
5575 bool found = false;
5576
5577 for (index = 0 ; index < NUM_MAX_SUBSTREAM ; index++) {
5578 if (m_attachedSubStreams[index].streamId == stream_id) {
5579 found = true;
5580 break;
5581 }
5582 }
5583 if (!found)
5584 return BAD_VALUE;
5585 m_attachedSubStreams[index].streamId = -1;
5586 m_attachedSubStreams[index].priority = 0;
5587 m_numRegisteredStream--;
5588 return NO_ERROR;
74d78ebe
SK		 5589}
5590
c15a6b00
JS		 5591int ExynosCameraHWInterface2::createIonClient(ion_client ionClient)
5592{
5593 if (ionClient == 0) {
5594 ionClient = ion_client_create();
5595 if (ionClient < 0) {
13d8c7b4 5596 ALOGE("[%s]src ion client create failed, value = %d\n", __FUNCTION__, ionClient);
c15a6b00
JS		 5597 return 0;
5598 }
5599 }
c15a6b00
JS		 5600 return ionClient;
5601}
5602
5603int ExynosCameraHWInterface2::deleteIonClient(ion_client ionClient)
5604{
5605 if (ionClient != 0) {
5606 if (ionClient > 0) {
5607 ion_client_destroy(ionClient);
5608 }
5609 ionClient = 0;
5610 }
c15a6b00
JS		 5611 return ionClient;
5612}
5613
13d8c7b4 5614int ExynosCameraHWInterface2::allocCameraMemory(ion_client ionClient, ExynosBuffer *buf, int iMemoryNum)
181e425e
SK		 5615{
5616 return allocCameraMemory(ionClient, buf, iMemoryNum, 0);
5617}
5618
5619int ExynosCameraHWInterface2::allocCameraMemory(ion_client ionClient, ExynosBuffer *buf, int iMemoryNum, int cacheFlag)
c15a6b00
JS		 5620{
5621 int ret = 0;
5622 int i = 0;
181e425e 5623 int flag = 0;
c15a6b00
JS		 5624
5625 if (ionClient == 0) {
13d8c7b4 5626 ALOGE("[%s] ionClient is zero (%d)\n", __FUNCTION__, ionClient);
c15a6b00
JS		 5627 return -1;
5628 }
5629
181e425e 5630 for (i = 0 ; i < iMemoryNum ; i++) {
13d8c7b4 5631 if (buf->size.extS[i] == 0) {
c15a6b00
JS		 5632 break;
5633 }
181e425e
SK		 5634 if (1 << i & cacheFlag)
5635 flag = ION_FLAG_CACHED;
5636 else
5637 flag = 0;
13d8c7b4 5638 buf->fd.extFd[i] = ion_alloc(ionClient, \
181e425e 5639 buf->size.extS[i], 0, ION_HEAP_EXYNOS_MASK, flag);
13d8c7b4
SK		 5640 if ((buf->fd.extFd[i] == -1) ||(buf->fd.extFd[i] == 0)) {
5641 ALOGE("[%s]ion_alloc(%d) failed\n", __FUNCTION__, buf->size.extS[i]);
5642 buf->fd.extFd[i] = -1;
c15a6b00
JS		 5643 freeCameraMemory(buf, iMemoryNum);
5644 return -1;
5645 }
5646
13d8c7b4
SK		 5647 buf->virt.extP[i] = (char *)ion_map(buf->fd.extFd[i], \
5648 buf->size.extS[i], 0);
5649 if ((buf->virt.extP[i] == (char *)MAP_FAILED) || (buf->virt.extP[i] == NULL)) {
5650 ALOGE("[%s]src ion map failed(%d)\n", __FUNCTION__, buf->size.extS[i]);
5651 buf->virt.extP[i] = (char *)MAP_FAILED;
c15a6b00
JS		 5652 freeCameraMemory(buf, iMemoryNum);
5653 return -1;
5654 }
181e425e 5655 ALOGV("allocCameraMem : [%d][0x%08x] size(%d) flag(%d)", i, (unsigned int)(buf->virt.extP[i]), buf->size.extS[i], flag);
c15a6b00
JS		 5656 }
5657
5658 return ret;
5659}
5660
13d8c7b4 5661void ExynosCameraHWInterface2::freeCameraMemory(ExynosBuffer *buf, int iMemoryNum)
c15a6b00 5662{
13d8c7b4 5663
5506cebf 5664 int i = 0 ;
15fd8231 5665 int ret = 0;
c15a6b00
JS		 5666
5667 for (i=0;i<iMemoryNum;i++) {
13d8c7b4
SK		 5668 if (buf->fd.extFd[i] != -1) {
5669 if (buf->virt.extP[i] != (char *)MAP_FAILED) {
15fd8231
SK		 5670 ret = ion_unmap(buf->virt.extP[i], buf->size.extS[i]);
5671 if (ret < 0)
5672 ALOGE("ERR(%s)", __FUNCTION__);
c15a6b00 5673 }
13d8c7b4 5674 ion_free(buf->fd.extFd[i]);
c15a6b00 5675 }
13d8c7b4
SK		 5676 buf->fd.extFd[i] = -1;
5677 buf->virt.extP[i] = (char *)MAP_FAILED;
5678 buf->size.extS[i] = 0;
c15a6b00
JS		 5679 }
5680}
5681
13d8c7b4 5682void ExynosCameraHWInterface2::initCameraMemory(ExynosBuffer *buf, int iMemoryNum)
c15a6b00
JS		 5683{
5684 int i =0 ;
5685 for (i=0;i<iMemoryNum;i++) {
13d8c7b4
SK		 5686 buf->virt.extP[i] = (char *)MAP_FAILED;
5687 buf->fd.extFd[i] = -1;
5688 buf->size.extS[i] = 0;
c15a6b00
JS		 5689 }
5690}
5691
5692
13d8c7b4
SK		 5693
5694
9dd63e1f 5695static camera2_device_t *g_cam2_device = NULL;
b5237e6b 5696static bool g_camera_vaild = false;
daa1fcd6 5697ExynosCamera2 * g_camera2[2] = { NULL, NULL };
c15a6b00
JS		 5698
5699static int HAL2_camera_device_close(struct hw_device_t* device)
5700{
ed4ad5fe 5701 ALOGD("(%s): ENTER", __FUNCTION__);
c15a6b00 5702 if (device) {
9dd63e1f 5703
c15a6b00 5704 camera2_device_t *cam_device = (camera2_device_t *)device;
ad37861e
SK		 5705 ALOGV("cam_device(0x%08x):", (unsigned int)cam_device);
5706 ALOGV("g_cam2_device(0x%08x):", (unsigned int)g_cam2_device);
c15a6b00 5707 delete static_cast<ExynosCameraHWInterface2 *>(cam_device->priv);
ad37861e 5708 g_cam2_device = NULL;
c15a6b00 5709 free(cam_device);
b5237e6b 5710 g_camera_vaild = false;
c15a6b00 5711 }
15fd8231 5712
ed4ad5fe 5713 ALOGD("(%s): EXIT", __FUNCTION__);
c15a6b00
JS		 5714 return 0;
5715}
5716
5717static inline ExynosCameraHWInterface2 *obj(const struct camera2_device *dev)
5718{
5719 return reinterpret_cast<ExynosCameraHWInterface2 *>(dev->priv);
5720}
5721
5722static int HAL2_device_set_request_queue_src_ops(const struct camera2_device *dev,
5723 const camera2_request_queue_src_ops_t *request_src_ops)
5724{
13d8c7b4 5725 ALOGV("DEBUG(%s):", __FUNCTION__);
c15a6b00
JS		 5726 return obj(dev)->setRequestQueueSrcOps(request_src_ops);
5727}
5728
5729static int HAL2_device_notify_request_queue_not_empty(const struct camera2_device *dev)
5730{
13d8c7b4 5731 ALOGV("DEBUG(%s):", __FUNCTION__);
c15a6b00
JS		 5732 return obj(dev)->notifyRequestQueueNotEmpty();
5733}
5734
5735static int HAL2_device_set_frame_queue_dst_ops(const struct camera2_device *dev,
5736 const camera2_frame_queue_dst_ops_t *frame_dst_ops)
5737{
13d8c7b4 5738 ALOGV("DEBUG(%s):", __FUNCTION__);
c15a6b00
JS		 5739 return obj(dev)->setFrameQueueDstOps(frame_dst_ops);
5740}
5741
5742static int HAL2_device_get_in_progress_count(const struct camera2_device *dev)
5743{
13d8c7b4 5744 ALOGV("DEBUG(%s):", __FUNCTION__);
c15a6b00
JS		 5745 return obj(dev)->getInProgressCount();
5746}
5747
5748static int HAL2_device_flush_captures_in_progress(const struct camera2_device *dev)
5749{
13d8c7b4 5750 ALOGV("DEBUG(%s):", __FUNCTION__);
c15a6b00
JS		 5751 return obj(dev)->flushCapturesInProgress();
5752}
5753
5754static int HAL2_device_construct_default_request(const struct camera2_device *dev,
5755 int request_template, camera_metadata_t **request)
5756{
13d8c7b4 5757 ALOGV("DEBUG(%s):", __FUNCTION__);
c15a6b00
JS		 5758 return obj(dev)->constructDefaultRequest(request_template, request);
5759}
5760
5761static int HAL2_device_allocate_stream(
5762 const struct camera2_device *dev,
5763 // inputs
5764 uint32_t width,
5765 uint32_t height,
5766 int format,
5767 const camera2_stream_ops_t *stream_ops,
5768 // outputs
5769 uint32_t *stream_id,
5770 uint32_t *format_actual,
5771 uint32_t *usage,
5772 uint32_t *max_buffers)
5773{
9dd63e1f 5774 ALOGV("(%s): ", __FUNCTION__);
c15a6b00
JS		 5775 return obj(dev)->allocateStream(width, height, format, stream_ops,
5776 stream_id, format_actual, usage, max_buffers);
5777}
5778
c15a6b00
JS		 5779static int HAL2_device_register_stream_buffers(const struct camera2_device *dev,
5780 uint32_t stream_id,
5781 int num_buffers,
5782 buffer_handle_t *buffers)
5783{
13d8c7b4 5784 ALOGV("DEBUG(%s):", __FUNCTION__);
c15a6b00
JS		 5785 return obj(dev)->registerStreamBuffers(stream_id, num_buffers, buffers);
5786}
5787
5788static int HAL2_device_release_stream(
5789 const struct camera2_device *dev,
5790 uint32_t stream_id)
5791{
ad37861e 5792 ALOGV("DEBUG(%s)(id: %d):", __FUNCTION__, stream_id);
b5237e6b
SK		 5793 if (!g_camera_vaild)
5794 return 0;
c15a6b00
JS		 5795 return obj(dev)->releaseStream(stream_id);
5796}
5797
5798static int HAL2_device_allocate_reprocess_stream(
5799 const struct camera2_device *dev,
5800 uint32_t width,
5801 uint32_t height,
5802 uint32_t format,
5803 const camera2_stream_in_ops_t *reprocess_stream_ops,
5804 // outputs
5805 uint32_t *stream_id,
5806 uint32_t *consumer_usage,
5807 uint32_t *max_buffers)
5808{
13d8c7b4 5809 ALOGV("DEBUG(%s):", __FUNCTION__);
c15a6b00
JS		 5810 return obj(dev)->allocateReprocessStream(width, height, format, reprocess_stream_ops,
5811 stream_id, consumer_usage, max_buffers);
5812}
5813
2b0421d1
EVT		 5814static int HAL2_device_allocate_reprocess_stream_from_stream(
5815 const struct camera2_device *dev,
5816 uint32_t output_stream_id,
5817 const camera2_stream_in_ops_t *reprocess_stream_ops,
5818 // outputs
5819 uint32_t *stream_id)
5820{
5821 ALOGV("DEBUG(%s):", __FUNCTION__);
5506cebf
SK		 5822 return obj(dev)->allocateReprocessStreamFromStream(output_stream_id,
5823 reprocess_stream_ops, stream_id);
2b0421d1
EVT		 5824}
5825
c15a6b00
JS		 5826static int HAL2_device_release_reprocess_stream(
5827 const struct camera2_device *dev,
5828 uint32_t stream_id)
5829{
13d8c7b4 5830 ALOGV("DEBUG(%s):", __FUNCTION__);
c15a6b00
JS		 5831 return obj(dev)->releaseReprocessStream(stream_id);
5832}
5833
5834static int HAL2_device_trigger_action(const struct camera2_device *dev,
5835 uint32_t trigger_id,
5836 int ext1,
5837 int ext2)
5838{
13d8c7b4 5839 ALOGV("DEBUG(%s):", __FUNCTION__);
c15a6b00
JS		 5840 return obj(dev)->triggerAction(trigger_id, ext1, ext2);
5841}
5842
5843static int HAL2_device_set_notify_callback(const struct camera2_device *dev,
5844 camera2_notify_callback notify_cb,
5845 void *user)
5846{
13d8c7b4 5847 ALOGV("DEBUG(%s):", __FUNCTION__);
c15a6b00
JS		 5848 return obj(dev)->setNotifyCallback(notify_cb, user);
5849}
5850
5851static int HAL2_device_get_metadata_vendor_tag_ops(const struct camera2_device*dev,
5852 vendor_tag_query_ops_t **ops)
5853{
13d8c7b4 5854 ALOGV("DEBUG(%s):", __FUNCTION__);
c15a6b00
JS		 5855 return obj(dev)->getMetadataVendorTagOps(ops);
5856}
5857
5858static int HAL2_device_dump(const struct camera2_device *dev, int fd)
5859{
13d8c7b4 5860 ALOGV("DEBUG(%s):", __FUNCTION__);
c15a6b00
JS		 5861 return obj(dev)->dump(fd);
5862}
5863
5864
5865
5866
5867
5868static int HAL2_getNumberOfCameras()
5869{
9dd63e1f
SK		 5870 ALOGV("(%s): returning 2", __FUNCTION__);
5871 return 2;
c15a6b00
JS		 5872}
5873
5874
c15a6b00
JS		 5875static int HAL2_getCameraInfo(int cameraId, struct camera_info *info)
5876{
ad37861e 5877 ALOGV("DEBUG(%s): cameraID: %d", __FUNCTION__, cameraId);
9dd63e1f 5878 static camera_metadata_t * mCameraInfo[2] = {NULL, NULL};
ad37861e 5879
c15a6b00 5880 status_t res;
13d8c7b4 5881
daa1fcd6 5882 if (cameraId == 0) {
9dd63e1f 5883 info->facing = CAMERA_FACING_BACK;
daa1fcd6
SK		 5884 if (!g_camera2[0])
5885 g_camera2[0] = new ExynosCamera2(0);
5886 }
5887 else if (cameraId == 1) {
9dd63e1f 5888 info->facing = CAMERA_FACING_FRONT;
daa1fcd6
SK		 5889 if (!g_camera2[1])
5890 g_camera2[1] = new ExynosCamera2(1);
5891 }
5892 else
5893 return BAD_VALUE;
5894
c15a6b00
JS		 5895 info->orientation = 0;
5896 info->device_version = HARDWARE_DEVICE_API_VERSION(2, 0);
9dd63e1f 5897 if (mCameraInfo[cameraId] == NULL) {
daa1fcd6 5898 res = g_camera2[cameraId]->constructStaticInfo(&(mCameraInfo[cameraId]), cameraId, true);
c15a6b00
JS		 5899 if (res != OK) {
5900 ALOGE("%s: Unable to allocate static info: %s (%d)",
13d8c7b4 5901 __FUNCTION__, strerror(-res), res);
c15a6b00
JS		 5902 return res;
5903 }
daa1fcd6 5904 res = g_camera2[cameraId]->constructStaticInfo(&(mCameraInfo[cameraId]), cameraId, false);
c15a6b00
JS		 5905 if (res != OK) {
5906 ALOGE("%s: Unable to fill in static info: %s (%d)",
13d8c7b4 5907 __FUNCTION__, strerror(-res), res);
c15a6b00
JS		 5908 return res;
5909 }
5910 }
9dd63e1f 5911 info->static_camera_characteristics = mCameraInfo[cameraId];
13d8c7b4 5912 return NO_ERROR;
c15a6b00
JS		 5913}
5914
5915#define SET_METHOD(m) m : HAL2_device_##m
5916
5917static camera2_device_ops_t camera2_device_ops = {
5918 SET_METHOD(set_request_queue_src_ops),
5919 SET_METHOD(notify_request_queue_not_empty),
5920 SET_METHOD(set_frame_queue_dst_ops),
5921 SET_METHOD(get_in_progress_count),
5922 SET_METHOD(flush_captures_in_progress),
5923 SET_METHOD(construct_default_request),
5924 SET_METHOD(allocate_stream),
5925 SET_METHOD(register_stream_buffers),
5926 SET_METHOD(release_stream),
5927 SET_METHOD(allocate_reprocess_stream),
2b0421d1 5928 SET_METHOD(allocate_reprocess_stream_from_stream),
c15a6b00
JS		 5929 SET_METHOD(release_reprocess_stream),
5930 SET_METHOD(trigger_action),
5931 SET_METHOD(set_notify_callback),
5932 SET_METHOD(get_metadata_vendor_tag_ops),
5933 SET_METHOD(dump),
5934};
5935
5936#undef SET_METHOD
5937
5938
5939static int HAL2_camera_device_open(const struct hw_module_t* module,
5940 const char *id,
5941 struct hw_device_t** device)
5942{
c15a6b00 5943 int cameraId = atoi(id);
6044e509 5944 int openInvalid = 0;
9dd63e1f 5945
b5237e6b 5946 g_camera_vaild = false;
ad37861e 5947 ALOGV("\n\n>>> I'm Samsung's CameraHAL_2(ID:%d) <<<\n\n", cameraId);
c15a6b00 5948 if (cameraId < 0 || cameraId >= HAL2_getNumberOfCameras()) {
13d8c7b4 5949 ALOGE("ERR(%s):Invalid camera ID %s", __FUNCTION__, id);
c15a6b00
JS		 5950 return -EINVAL;
5951 }
5952
ad37861e 5953 ALOGV("g_cam2_device : 0x%08x", (unsigned int)g_cam2_device);
c15a6b00
JS		 5954 if (g_cam2_device) {
5955 if (obj(g_cam2_device)->getCameraId() == cameraId) {
13d8c7b4 5956 ALOGV("DEBUG(%s):returning existing camera ID %s", __FUNCTION__, id);
c15a6b00
JS		 5957 goto done;
5958 } else {
9dd63e1f
SK		 5959
5960 while (g_cam2_device)
5961 usleep(10000);
c15a6b00
JS		 5962 }
5963 }
5964
5965 g_cam2_device = (camera2_device_t *)malloc(sizeof(camera2_device_t));
ad37861e 5966 ALOGV("g_cam2_device : 0x%08x", (unsigned int)g_cam2_device);
9dd63e1f 5967
c15a6b00
JS		 5968 if (!g_cam2_device)
5969 return -ENOMEM;
5970
5971 g_cam2_device->common.tag = HARDWARE_DEVICE_TAG;
5972 g_cam2_device->common.version = CAMERA_DEVICE_API_VERSION_2_0;
5973 g_cam2_device->common.module = const_cast<hw_module_t *>(module);
5974 g_cam2_device->common.close = HAL2_camera_device_close;
5975
5976 g_cam2_device->ops = &camera2_device_ops;
5977
13d8c7b4 5978 ALOGV("DEBUG(%s):open camera2 %s", __FUNCTION__, id);
c15a6b00 5979
6044e509
SK		 5980 g_cam2_device->priv = new ExynosCameraHWInterface2(cameraId, g_cam2_device, g_camera2[cameraId], &openInvalid);
5981 if (!openInvalid) {
5506cebf 5982 ALOGE("DEBUG(%s): ExynosCameraHWInterface2 creation failed", __FUNCTION__);
6f19b6cf 5983 return -ENODEV;
6044e509 5984 }
c15a6b00
JS		 5985done:
5986 *device = (hw_device_t *)g_cam2_device;
13d8c7b4 5987 ALOGV("DEBUG(%s):opened camera2 %s (%p)", __FUNCTION__, id, *device);
b5237e6b 5988 g_camera_vaild = true;
c15a6b00
JS		 5989
5990 return 0;
5991}
5992
5993
5994static hw_module_methods_t camera_module_methods = {
5995 open : HAL2_camera_device_open
5996};
5997
5998extern "C" {
5999 struct camera_module HAL_MODULE_INFO_SYM = {
6000 common : {
6001 tag : HARDWARE_MODULE_TAG,
6002 module_api_version : CAMERA_MODULE_API_VERSION_2_0,
6003 hal_api_version : HARDWARE_HAL_API_VERSION,
6004 id : CAMERA_HARDWARE_MODULE_ID,
6005 name : "Exynos Camera HAL2",
6006 author : "Samsung Corporation",
6007 methods : &camera_module_methods,
6008 dso: NULL,
6009 reserved: {0},
6010 },
6011 get_number_of_cameras : HAL2_getNumberOfCameras,
6012 get_camera_info : HAL2_getCameraInfo
6013 };
6014}
6015
6016}; // namespace android