libcamera/34xx/hal1/ExynosCameraFrameFactoryFront.cpp

   1 /*
   2 **
   3 ** Copyright 2014, Samsung Electronics Co. LTD
   4 **
   5 ** Licensed under the Apache License, Version 2.0 (the "License");
   6 ** you may not use this file except in compliance with the License.
   7 ** You may obtain a copy of the License at
   8 **
   9 **     http://www.apache.org/licenses/LICENSE-2.0
  10 **
  11 ** Unless required by applicable law or agreed to in writing, software
  12 ** distributed under the License is distributed on an "AS IS" BASIS,
  13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 ** See the License for the specific language governing permissions and
  15 ** limitations under the License.
  16 */
  17
  18 /* #define LOG_NDEBUG 0 */
  19 #define LOG_TAG "ExynosCameraFrameFactoryFront"
  20 #include <cutils/log.h>
  21
  22 #include "ExynosCameraFrameFactoryFront.h"
  23
  24 namespace android {
  25
  26 ExynosCameraFrameFactoryFront::~ExynosCameraFrameFactoryFront()
  27 {
  28     int ret = 0;
  29
  30     ret = destroy();
  31     if (ret < 0)
  32         CLOGE("ERR(%s[%d]):destroy fail", __FUNCTION__, __LINE__);
  33 }
  34
  35 status_t ExynosCameraFrameFactoryFront::create(__unused bool active)
  36 {
  37     CLOGI("INFO(%s[%d])", __FUNCTION__, __LINE__);
  38
  39     m_setupConfig();
  40
  41     int ret = 0;
  42     int32_t nodeNums[MAX_NODE];
  43     for (int i = 0; i < MAX_NODE; i++)
  44         nodeNums[i] = -1;
  45
  46     m_pipes[INDEX(PIPE_FLITE)] = (ExynosCameraPipe*)new ExynosCameraPipeFlite(m_cameraId, m_parameters, false, m_nodeNums[INDEX(PIPE_FLITE)]);
  47     m_pipes[INDEX(PIPE_FLITE)]->setPipeId(PIPE_FLITE);
  48     m_pipes[INDEX(PIPE_FLITE)]->setPipeName("PIPE_FLITE");
  49
  50     m_pipes[INDEX(PIPE_3AA)] = (ExynosCameraPipe*)new ExynosCameraMCPipe(m_cameraId, m_parameters, false, &m_deviceInfo[INDEX(PIPE_3AA)]);
  51     m_pipes[INDEX(PIPE_3AA)]->setPipeId(PIPE_3AA);
  52     m_pipes[INDEX(PIPE_3AA)]->setPipeName("PIPE_3AA");
  53
  54     m_pipes[INDEX(PIPE_ISP)] = (ExynosCameraPipe*)new ExynosCameraMCPipe(m_cameraId, m_parameters, false, &m_deviceInfo[INDEX(PIPE_ISP)]);
  55     m_pipes[INDEX(PIPE_ISP)]->setPipeId(PIPE_ISP);
  56     m_pipes[INDEX(PIPE_ISP)]->setPipeName("PIPE_ISP");
  57
  58     m_pipes[INDEX(PIPE_GSC)] = (ExynosCameraPipe*)new ExynosCameraPipeGSC(m_cameraId, m_parameters, true, m_nodeNums[INDEX(PIPE_GSC)]);
  59     m_pipes[INDEX(PIPE_GSC)]->setPipeId(PIPE_GSC);
  60     m_pipes[INDEX(PIPE_GSC)]->setPipeName("PIPE_GSC");
  61
  62     m_pipes[INDEX(PIPE_GSC_VIDEO)] = (ExynosCameraPipe*)new ExynosCameraPipeGSC(m_cameraId, m_parameters, false, m_nodeNums[INDEX(PIPE_GSC_VIDEO)]);
  63     m_pipes[INDEX(PIPE_GSC_VIDEO)]->setPipeId(PIPE_GSC_VIDEO);
  64     m_pipes[INDEX(PIPE_GSC_VIDEO)]->setPipeName("PIPE_GSC_VIDEO");
  65
  66     if (m_supportReprocessing == false) {
  67         m_pipes[INDEX(PIPE_GSC_PICTURE)] = (ExynosCameraPipe*)new ExynosCameraPipeGSC(m_cameraId, m_parameters, true, m_nodeNums[INDEX(PIPE_GSC_PICTURE)]);
  68         m_pipes[INDEX(PIPE_GSC_PICTURE)]->setPipeId(PIPE_GSC_PICTURE);
  69         m_pipes[INDEX(PIPE_GSC_PICTURE)]->setPipeName("PIPE_GSC_PICTURE");
  70
  71         m_pipes[INDEX(PIPE_JPEG)] = (ExynosCameraPipe*)new ExynosCameraPipeJpeg(m_cameraId, m_parameters, true, m_nodeNums[INDEX(PIPE_JPEG)]);
  72         m_pipes[INDEX(PIPE_JPEG)]->setPipeId(PIPE_JPEG);
  73         m_pipes[INDEX(PIPE_JPEG)]->setPipeName("PIPE_JPEG");
  74     }
  75
  76     /* flite pipe initialize */
  77     ret = m_pipes[INDEX(PIPE_FLITE)]->create(m_sensorIds[INDEX(PIPE_FLITE)]);
  78     if (ret < 0) {
  79         CLOGE("ERR(%s[%d]):FLITE create fail, ret(%d)", __FUNCTION__, __LINE__, ret);
  80         /* TODO: exception handling */
  81         return INVALID_OPERATION;
  82     }
  83     CLOGD("DEBUG(%s):Pipe(%d) created", __FUNCTION__, INDEX(PIPE_FLITE));
  84
  85     /* ISP pipe initialize */
  86     ret = m_pipes[INDEX(PIPE_ISP)]->create();
  87     if (ret < 0) {
  88         CLOGE("ERR(%s[%d]):ISP create fail, ret(%d)", __FUNCTION__, __LINE__, ret);
  89         /* TODO: exception handling */
  90         return INVALID_OPERATION;
  91     }
  92     CLOGD("DEBUG(%s):Pipe(%d) created", __FUNCTION__, INDEX(PIPE_ISP));
  93
  94     /* 3AA pipe initialize */
  95     ret = m_pipes[INDEX(PIPE_3AA)]->create();
  96     if (ret < 0) {
  97         CLOGE("ERR(%s[%d]):3AA create fail, ret(%d)", __FUNCTION__, __LINE__, ret);
  98         /* TODO: exception handling */
  99         return INVALID_OPERATION;
 100     }
 101     CLOGD("DEBUG(%s):Pipe(%d) created", __FUNCTION__, INDEX(PIPE_3AA));
 102
 103     /* GSC_PREVIEW pipe initialize */
 104     ret = m_pipes[INDEX(PIPE_GSC)]->create();
 105     if (ret < 0) {
 106         CLOGE("ERR(%s[%d]):GSC create fail, ret(%d)", __FUNCTION__, __LINE__, ret);
 107         /* TODO: exception handling */
 108         return INVALID_OPERATION;
 109     }
 110     CLOGD("DEBUG(%s):Pipe(%d) created", __FUNCTION__, INDEX(PIPE_GSC));
 111
 112     ret = m_pipes[INDEX(PIPE_GSC_VIDEO)]->create();
 113     if (ret < 0) {
 114         CLOGE("ERR(%s[%d]):PIPE_GSC_VIDEO create fail, ret(%d)", __FUNCTION__, __LINE__, ret);
 115         /* TODO: exception handling */
 116         return INVALID_OPERATION;
 117     }
 118     CLOGD("DEBUG(%s):Pipe(%d) created", __FUNCTION__, INDEX(PIPE_GSC_VIDEO));
 119
 120     if (m_supportReprocessing == false) {
 121         /* GSC_PICTURE pipe initialize */
 122         ret = m_pipes[INDEX(PIPE_GSC_PICTURE)]->create();
 123         if (ret < 0) {
 124             CLOGE("ERR(%s[%d]):GSC_PICTURE create fail, ret(%d)", __FUNCTION__, __LINE__, ret);
 125             /* TODO: exception handling */
 126             return INVALID_OPERATION;
 127         }
 128         CLOGD("DEBUG(%s):Pipe(%d) created", __FUNCTION__, INDEX(PIPE_GSC_PICTURE));
 129
 130         /* JPEG pipe initialize */
 131         ret = m_pipes[INDEX(PIPE_JPEG)]->create();
 132         if (ret < 0) {
 133             CLOGE("ERR(%s[%d]):JPEG create fail, ret(%d)", __FUNCTION__, __LINE__, ret);
 134             /* TODO: exception handling */
 135             return INVALID_OPERATION;
 136         }
 137         CLOGD("DEBUG(%s):Pipe(%d) created", __FUNCTION__, INDEX(PIPE_JPEG));
 138     }
 139
 140     /* EOS */
 141     ret = m_pipes[INDEX(PIPE_3AA)]->setControl(V4L2_CID_IS_END_OF_STREAM, 1);
 142     if (ret < 0) {
 143         CLOGE("ERR(%s[%d]):PIPE_%d V4L2_CID_IS_END_OF_STREAM fail, ret(%d)", __FUNCTION__, __LINE__, PIPE_3AA, ret);
 144         /* TODO: exception handling */
 145         return INVALID_OPERATION;
 146     }
 147
 148     m_setCreate(true);
 149
 150     return NO_ERROR;
 151 }
 152
 153 status_t ExynosCameraFrameFactoryFront::m_fillNodeGroupInfo(ExynosCameraFrame *frame)
 154 {
 155     camera2_node_group node_group_info_3aa, node_group_info_isp, node_group_info_dis;
 156     int zoom = m_parameters->getZoomLevel();
 157     int previewW = 0, previewH = 0;
 158     int pictureW = 0, pictureH = 0;
 159     ExynosRect bnsSize;       /* == bayerCropInputSize */
 160     ExynosRect bayerCropSize;
 161     ExynosRect bdsSize;
 162     int perFramePos = 0;
 163     bool tpu = false;
 164     bool dual = true;
 165
 166     m_parameters->getHwPreviewSize(&previewW, &previewH);
 167     m_parameters->getPictureSize(&pictureW, &pictureH);
 168     m_parameters->getPreviewBayerCropSize(&bnsSize, &bayerCropSize);
 169     m_parameters->getPreviewBdsSize(&bdsSize);
 170
 171     memset(&node_group_info_3aa, 0x0, sizeof(camera2_node_group));
 172     memset(&node_group_info_isp, 0x0, sizeof(camera2_node_group));
 173     memset(&node_group_info_dis, 0x0, sizeof(camera2_node_group));
 174
 175     /* should add this request value in FrameFactory */
 176     /* 3AA */
 177     node_group_info_3aa.leader.request = 1;
 178
 179     /* 3AC */
 180     perFramePos = (m_cameraId == CAMERA_ID_BACK) ? PERFRAME_BACK_3AC_POS : PERFRAME_FRONT_3AC_POS;
 181     node_group_info_3aa.capture[perFramePos].request = frame->getRequest(PIPE_3AC);
 182
 183     /* 3AP */
 184     perFramePos = (m_cameraId == CAMERA_ID_BACK) ? PERFRAME_BACK_3AP_POS : PERFRAME_FRONT_3AP_POS;
 185     node_group_info_3aa.capture[perFramePos].request = frame->getRequest(PIPE_3AP);
 186
 187     /* should add this request value in FrameFactory */
 188     /* ISP */
 189     node_group_info_isp.leader.request = 1;
 190
 191     /* SCC */
 192     perFramePos = (m_cameraId == CAMERA_ID_BACK) ? PERFRAME_BACK_SCC_POS : PERFRAME_FRONT_SCC_POS;
 193
 194     if (m_supportSCC == true)
 195         node_group_info_isp.capture[perFramePos].request = frame->getRequest(PIPE_SCC);
 196     else
 197         node_group_info_isp.capture[perFramePos].request = frame->getRequest(PIPE_ISPC);
 198
 199     memcpy(&node_group_info_dis, &node_group_info_isp, sizeof (camera2_node_group));
 200
 201     if (m_requestISPC == true) {
 202         perFramePos = (m_cameraId == CAMERA_ID_BACK) ? PERFRAME_BACK_ISPC_POS : PERFRAME_FRONT_ISPC_POS;
 203         node_group_info_3aa.capture[perFramePos].request = frame->getRequest(PIPE_ISPC);
 204     }
 205
 206     ExynosCameraNodeGroup3AA::updateNodeGroupInfo(
 207         m_cameraId,
 208         &node_group_info_3aa,
 209         bayerCropSize,
 210         bdsSize,
 211         previewW, previewH,
 212         pictureW, pictureH);
 213
 214     ExynosCameraNodeGroupISP::updateNodeGroupInfo(
 215         m_cameraId,
 216         &node_group_info_isp,
 217         bayerCropSize,
 218         bdsSize,
 219         previewW, previewH,
 220         pictureW, pictureH,
 221         tpu);
 222
 223     ExynosCameraNodeGroupDIS::updateNodeGroupInfo(
 224         m_cameraId,
 225         &node_group_info_dis,
 226         bayerCropSize,
 227         bdsSize,
 228         previewW, previewH,
 229         pictureW, pictureH);
 230
 231     if (m_requestISPC == true) {
 232         perFramePos = (m_cameraId == CAMERA_ID_BACK) ? PERFRAME_BACK_SCP_POS : PERFRAME_FRONT_SCP_POS;
 233         for(int i=0 ; i < 4 ; i++) {
 234             node_group_info_3aa.capture[PERFRAME_FRONT_ISPC_POS].input.cropRegion[i] = node_group_info_3aa.capture[perFramePos].input.cropRegion[i];
 235             node_group_info_3aa.capture[PERFRAME_FRONT_ISPC_POS].output.cropRegion[i] = node_group_info_3aa.capture[perFramePos].input.cropRegion[i];
 236         }
 237     }
 238
 239     frame->storeNodeGroupInfo(&node_group_info_3aa, PERFRAME_INFO_3AA, zoom);
 240     frame->storeNodeGroupInfo(&node_group_info_isp, PERFRAME_INFO_ISP, zoom);
 241     frame->storeNodeGroupInfo(&node_group_info_dis, PERFRAME_INFO_DIS, zoom);
 242
 243     return NO_ERROR;
 244 }
 245
 246 ExynosCameraFrame *ExynosCameraFrameFactoryFront::createNewFrame(void)
 247 {
 248     int ret = 0;
 249     ExynosCameraFrameEntity *newEntity[MAX_NUM_PIPES] = {0};
 250     ExynosCameraFrame *frame = m_frameMgr->createFrame(m_parameters, m_frameCount, FRAME_TYPE_PREVIEW);
 251
 252     int requestEntityCount = 0;
 253     bool dzoomScaler = false;
 254     dzoomScaler = m_parameters->getZoomPreviewWIthScaler();
 255
 256     ret = m_initFrameMetadata(frame);
 257     if (ret < 0)
 258         CLOGE("(%s[%d]): frame(%d) metadata initialize fail", __FUNCTION__, __LINE__, m_frameCount);
 259
 260     if (m_requestFLITE) {
 261         /* set flite pipe to linkageList */
 262         newEntity[INDEX(PIPE_FLITE)] = new ExynosCameraFrameEntity(PIPE_FLITE, ENTITY_TYPE_OUTPUT_ONLY, ENTITY_BUFFER_FIXED);
 263         frame->addSiblingEntity(NULL, newEntity[INDEX(PIPE_FLITE)]);
 264         requestEntityCount++;
 265     }
 266
 267     /* set 3AA_ISP pipe to linkageList */
 268     newEntity[INDEX(PIPE_3AA)] = new ExynosCameraFrameEntity(PIPE_3AA, ENTITY_TYPE_INPUT_ONLY, ENTITY_BUFFER_FIXED);
 269     frame->addSiblingEntity(NULL, newEntity[INDEX(PIPE_3AA)]);
 270     requestEntityCount++;
 271
 272     if (m_supportReprocessing == false) {
 273         /* set GSC-Picture pipe to linkageList */
 274         newEntity[INDEX(PIPE_GSC_PICTURE)] = new ExynosCameraFrameEntity(PIPE_GSC_PICTURE, ENTITY_TYPE_INPUT_OUTPUT, ENTITY_BUFFER_FIXED);
 275         frame->addSiblingEntity(NULL, newEntity[INDEX(PIPE_GSC_PICTURE)]);
 276     }
 277
 278     /* set GSC pipe to linkageList */
 279     newEntity[INDEX(PIPE_GSC)] = new ExynosCameraFrameEntity(PIPE_GSC, ENTITY_TYPE_INPUT_OUTPUT, ENTITY_BUFFER_FIXED);
 280     frame->addSiblingEntity(NULL, newEntity[INDEX(PIPE_GSC)]);
 281     if (dzoomScaler) {
 282         requestEntityCount++;
 283     }
 284
 285     newEntity[INDEX(PIPE_GSC_VIDEO)] = new ExynosCameraFrameEntity(PIPE_GSC_VIDEO, ENTITY_TYPE_INPUT_OUTPUT, ENTITY_BUFFER_FIXED);
 286     frame->addSiblingEntity(NULL, newEntity[INDEX(PIPE_GSC_VIDEO)]);
 287
 288     if (m_supportReprocessing == false) {
 289         /* set JPEG pipe to linkageList */
 290         newEntity[INDEX(PIPE_JPEG)] = new ExynosCameraFrameEntity(PIPE_JPEG, ENTITY_TYPE_INPUT_OUTPUT, ENTITY_BUFFER_FIXED);
 291         frame->addSiblingEntity(NULL, newEntity[INDEX(PIPE_JPEG)]);
 292     }
 293
 294     ret = m_initPipelines(frame);
 295     if (ret < 0) {
 296         CLOGE("ERR(%s):m_initPipelines fail, ret(%d)", __FUNCTION__, ret);
 297     }
 298
 299     /* TODO: make it dynamic */
 300     frame->setNumRequestPipe(requestEntityCount);
 301
 302     m_fillNodeGroupInfo(frame);
 303
 304     m_frameCount++;
 305     return frame;
 306 }
 307
 308 status_t ExynosCameraFrameFactoryFront::initPipes(void)
 309 {
 310     CLOGI("INFO(%s[%d]) IN", __FUNCTION__, __LINE__);
 311
 312     int ret = 0;
 313     camera_pipe_info_t pipeInfo[MAX_NODE];
 314     camera_pipe_info_t nullPipeInfo;
 315
 316     int32_t nodeNums[MAX_NODE];
 317     int32_t sensorIds[MAX_NODE];
 318     int32_t secondarySensorIds[MAX_NODE];
 319     for (int i = 0; i < MAX_NODE; i++) {
 320         nodeNums[i] = -1;
 321         sensorIds[i] = -1;
 322         secondarySensorIds[i] = -1;
 323     }
 324
 325     ExynosRect tempRect;
 326     int maxSensorW = 0, maxSensorH = 0, hwSensorW = 0, hwSensorH = 0;
 327     int maxPreviewW = 0, maxPreviewH = 0, hwPreviewW = 0, hwPreviewH = 0;
 328     int maxPictureW = 0, maxPictureH = 0, hwPictureW = 0, hwPictureH = 0;
 329     int bayerFormat = CAMERA_BAYER_FORMAT;
 330     int previewFormat = m_parameters->getHwPreviewFormat();
 331     int pictureFormat = m_parameters->getHwPictureFormat();
 332     int hwVdisformat = m_parameters->getHWVdisFormat();
 333     bool hwVdis = m_parameters->getTpuEnabledMode();
 334     struct ExynosConfigInfo *config = m_parameters->getConfig();
 335     ExynosRect bdsSize;
 336     int perFramePos = 0;
 337     int stride = 0;
 338
 339 #ifdef DEBUG_RAWDUMP
 340     if (m_parameters->checkBayerDumpEnable()) {
 341         bayerFormat = CAMERA_DUMP_BAYER_FORMAT;
 342     }
 343 #endif
 344
 345     m_parameters->getMaxSensorSize(&maxSensorW, &maxSensorH);
 346     m_parameters->getHwSensorSize(&hwSensorW, &hwSensorH);
 347
 348     m_parameters->getMaxPreviewSize(&maxPreviewW, &maxPreviewH);
 349     m_parameters->getHwPreviewSize(&hwPreviewW, &hwPreviewH);
 350
 351     m_parameters->getMaxPictureSize(&maxPictureW, &maxPictureH);
 352     m_parameters->getHwPictureSize(&hwPictureW, &hwPictureH);
 353
 354     m_parameters->getPreviewBdsSize(&bdsSize);
 355
 356     /* When high speed recording mode, hw sensor size is fixed.
 357      * So, maxPreview size cannot exceed hw sensor size
 358      */
 359     if (m_parameters->getHighSpeedRecording()) {
 360         maxPreviewW = hwSensorW;
 361         maxPreviewH = hwSensorH;
 362     }
 363
 364     CLOGI("INFO(%s[%d]): MaxSensorSize(%dx%d), HWSensorSize(%dx%d)", __FUNCTION__, __LINE__, maxSensorW, maxSensorH, hwSensorW, hwSensorH);
 365     CLOGI("INFO(%s[%d]): MaxPreviewSize(%dx%d), HwPreviewSize(%dx%d)", __FUNCTION__, __LINE__, maxPreviewW, maxPreviewH, hwPreviewW, hwPreviewH);
 366     CLOGI("INFO(%s[%d]): HWPictureSize(%dx%d)", __FUNCTION__, __LINE__, hwPictureW, hwPictureH);
 367
 368
 369
 370 #ifdef DEBUG_RAWDUMP
 371     if (m_parameters->checkBayerDumpEnable()) {
 372         bayerFormat = CAMERA_DUMP_BAYER_FORMAT;
 373     }
 374 #endif
 375
 376     m_parameters->getMaxSensorSize(&maxSensorW, &maxSensorH);
 377     m_parameters->getHwSensorSize(&hwSensorW, &hwSensorH);
 378
 379     CLOGI("INFO(%s[%d]): MaxSensorSize(%dx%d), HWSensorSize(%dx%d)", __FUNCTION__, __LINE__, maxSensorW, maxSensorH, hwSensorW, hwSensorH);
 380
 381     /* FLITE pipe */
 382     for (int i = 0; i < MAX_NODE; i++)
 383         pipeInfo[i] = nullPipeInfo;
 384
 385     /* setParam for Frame rate : must after setInput on Flite */
 386     uint32_t min, max, frameRate;
 387     struct v4l2_streamparm streamParam;
 388
 389     memset(&streamParam, 0x0, sizeof(v4l2_streamparm));
 390     m_parameters->getPreviewFpsRange(&min, &max);
 391
 392     if (m_parameters->getScalableSensorMode() == true)
 393         frameRate = 24;
 394     else
 395         frameRate = max;
 396
 397     streamParam.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
 398     streamParam.parm.capture.timeperframe.numerator   = 1;
 399     streamParam.parm.capture.timeperframe.denominator = frameRate;
 400     CLOGI("INFO(%s[%d]:set framerate (denominator=%d)", __FUNCTION__, __LINE__, frameRate);
 401     ret = setParam(&streamParam, PIPE_FLITE);
 402     if (ret < 0) {
 403         CLOGE("ERR(%s[%d]):FLITE setParam fail, ret(%d)", __FUNCTION__, __LINE__, ret);
 404         return INVALID_OPERATION;
 405     }
 406
 407 #ifdef FIXED_SENSOR_SIZE
 408     tempRect.fullW = maxSensorW;
 409     tempRect.fullH = maxSensorH;
 410 #else
 411     tempRect.fullW = hwSensorW;
 412     tempRect.fullH = hwSensorH;
 413 #endif
 414     tempRect.colorFormat = bayerFormat;
 415
 416     pipeInfo[0].rectInfo = tempRect;
 417     pipeInfo[0].bufInfo.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
 418     pipeInfo[0].bufInfo.memory = V4L2_CAMERA_MEMORY_TYPE;
 419     pipeInfo[0].bufInfo.count = config->current->bufInfo.num_bayer_buffers;
 420     /* per frame info */
 421     pipeInfo[0].perFrameNodeGroupInfo.perframeSupportNodeNum = 0;
 422     pipeInfo[0].perFrameNodeGroupInfo.perFrameLeaderInfo.perFrameNodeType = PERFRAME_NODE_TYPE_NONE;
 423
 424 #ifdef CAMERA_PACKED_BAYER_ENABLE
 425 #ifdef DEBUG_RAWDUMP
 426     if (m_parameters->checkBayerDumpEnable()) {
 427         /* packed bayer bytesPerPlane */
 428         pipeInfo[0].bytesPerPlane[0] = ROUND_UP(pipeInfo[0].rectInfo.fullW, 10) * 2;
 429     }
 430     else
 431 #endif
 432     {
 433         /* packed bayer bytesPerPlane */
 434         pipeInfo[0].bytesPerPlane[0] = ROUND_UP(pipeInfo[0].rectInfo.fullW, 10) * 8 / 5;
 435     }
 436 #endif
 437
 438     ret = m_pipes[INDEX(PIPE_FLITE)]->setupPipe(pipeInfo, m_sensorIds[INDEX(PIPE_FLITE)]);
 439     if (ret < 0) {
 440         CLOGE("ERR(%s[%d]):FLITE setupPipe fail, ret(%d)", __FUNCTION__, __LINE__, ret);
 441         /* TODO: exception handling */
 442         return INVALID_OPERATION;
 443     }
 444
 445     /* set BNS ratio */
 446
 447     int bnsScaleRatio = 0;
 448     int bnsSize = 0;
 449     if( m_parameters->getHighSpeedRecording()
 450 #ifdef USE_BINNING_MODE
 451         || m_parameters->getBinningMode()
 452 #endif
 453     ) {
 454         bnsScaleRatio = 1000;
 455     } else {
 456         bnsScaleRatio = m_parameters->getBnsScaleRatio();
 457     }
 458     ret = m_pipes[INDEX(PIPE_FLITE)]->setControl(V4L2_CID_IS_S_BNS, bnsScaleRatio);
 459     if (ret < 0) {
 460         CLOGE("ERR(%s[%d]): set BNS(%d) fail, ret(%d)", __FUNCTION__, __LINE__, bnsScaleRatio, ret);
 461     } else {
 462         ret = m_pipes[INDEX(PIPE_FLITE)]->getControl(V4L2_CID_IS_G_BNS_SIZE, &bnsSize);
 463         if (ret < 0) {
 464             CLOGE("ERR(%s[%d]): get BNS size fail, ret(%d)", __FUNCTION__, __LINE__, ret);
 465             bnsSize = -1;
 466         }
 467     }
 468
 469     int bnsWidth = 0;
 470     int bnsHeight = 0;
 471     if (bnsSize > 0) {
 472         bnsHeight = bnsSize & 0xffff;
 473         bnsWidth = bnsSize >> 16;
 474
 475         CLOGI("INFO(%s[%d]): BNS scale down ratio(%.1f), size (%dx%d)", __FUNCTION__, __LINE__, (float)(bnsScaleRatio / 1000), bnsWidth, bnsHeight);
 476         m_parameters->setBnsSize(bnsWidth, bnsHeight);
 477     }
 478
 479     /* 3AS */
 480     enum NODE_TYPE t3asNodeType = getNodeType(PIPE_3AA);
 481
 482     for (int i = 0; i < MAX_NODE; i++)
 483         pipeInfo[i] = nullPipeInfo;
 484
 485     for (int i = 0; i < MAX_NODE; i++) {
 486         ret = m_pipes[INDEX(PIPE_3AA)]->setPipeId((enum NODE_TYPE)i, m_deviceInfo[PIPE_3AA].pipeId[i]);
 487         if (ret < 0) {
 488             CLOGE("ERR(%s[%d]):setPipeId(%d, %d) fail, ret(%d)", __FUNCTION__, __LINE__, i, m_deviceInfo[PIPE_3AA].pipeId[i], ret);
 489             return ret;
 490         }
 491
 492         sensorIds[i] = m_sensorIds[INDEX(PIPE_3AA)][i];
 493         secondarySensorIds[i] = m_secondarySensorIds[INDEX(PIPE_3AA)][i];
 494     }
 495
 496     if (m_flagFlite3aaOTF == true) {
 497         tempRect.fullW = 32;
 498         tempRect.fullH = 64;
 499         tempRect.colorFormat = bayerFormat;
 500
 501         pipeInfo[t3asNodeType].bufInfo.count = config->current->bufInfo.num_3aa_buffers;
 502     } else {
 503         tempRect.fullW = maxSensorW;
 504         tempRect.fullH = maxSensorH;
 505         tempRect.colorFormat = bayerFormat;
 506
 507 #ifdef CAMERA_PACKED_BAYER_ENABLE
 508 #ifdef DEBUG_RAWDUMP
 509         if (m_parameters->checkBayerDumpEnable()) {
 510             /* packed bayer bytesPerPlane */
 511             pipeInfo[t3asNodeType].bytesPerPlane[0] = ROUND_UP(tempRect.fullW, 10) * 2;
 512         }
 513         else
 514 #endif
 515         {
 516             /* packed bayer bytesPerPlane */
 517             pipeInfo[t3asNodeType].bytesPerPlane[0] = ROUND_UP(tempRect.fullW, 10) * 8 / 5;
 518         }
 519 #endif
 520
 521         pipeInfo[t3asNodeType].bufInfo.count = config->current->bufInfo.num_bayer_buffers;
 522     }
 523
 524     pipeInfo[t3asNodeType].rectInfo = tempRect;
 525     pipeInfo[t3asNodeType].bufInfo.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
 526     pipeInfo[t3asNodeType].bufInfo.memory = V4L2_CAMERA_MEMORY_TYPE;
 527
 528     /* per frame info */
 529     pipeInfo[t3asNodeType].perFrameNodeGroupInfo.perframeSupportNodeNum = CAPTURE_NODE_MAX;
 530     pipeInfo[t3asNodeType].perFrameNodeGroupInfo.perFrameLeaderInfo.perframeInfoIndex = PERFRAME_INFO_3AA;
 531
 532     pipeInfo[t3asNodeType].perFrameNodeGroupInfo.perFrameLeaderInfo.perFrameNodeType = PERFRAME_NODE_TYPE_LEADER;
 533     pipeInfo[t3asNodeType].perFrameNodeGroupInfo.perFrameLeaderInfo.perFrameVideoID = (m_deviceInfo[INDEX(PIPE_3AA)].nodeNum[t3asNodeType] - FIMC_IS_VIDEO_BAS_NUM);
 534
 535     /* 3AP */
 536     enum NODE_TYPE t3apNodeType = getNodeType(PIPE_3AP);
 537
 538     perFramePos = (m_cameraId == CAMERA_ID_BACK) ? PERFRAME_BACK_3AP_POS : PERFRAME_FRONT_3AP_POS;
 539     pipeInfo[t3asNodeType].perFrameNodeGroupInfo.perFrameCaptureInfo[perFramePos].perFrameNodeType = PERFRAME_NODE_TYPE_CAPTURE;
 540     pipeInfo[t3asNodeType].perFrameNodeGroupInfo.perFrameCaptureInfo[perFramePos].perFrameVideoID = (m_deviceInfo[INDEX(PIPE_3AA)].secondaryNodeNum[t3apNodeType] - FIMC_IS_VIDEO_BAS_NUM);
 541 #if 1
 542     tempRect.fullW = maxSensorW;
 543     tempRect.fullH = maxSensorH;
 544     tempRect.colorFormat = bayerFormat;
 545     pipeInfo[t3apNodeType].rectInfo = tempRect;
 546     pipeInfo[t3apNodeType].bufInfo.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
 547     pipeInfo[t3apNodeType].bufInfo.memory = V4L2_CAMERA_MEMORY_TYPE;
 548 #endif
 549     pipeInfo[t3apNodeType].perFrameNodeGroupInfo.perframeSupportNodeNum = 0;
 550     pipeInfo[t3apNodeType].perFrameNodeGroupInfo.perFrameLeaderInfo.perFrameNodeType = PERFRAME_NODE_TYPE_NONE;
 551
 552     /* ISPS */
 553     enum NODE_TYPE ispsNodeType = getNodeType(PIPE_ISP);
 554
 555     tempRect.fullW = bdsSize.w;
 556     tempRect.fullH = bdsSize.h;
 557     tempRect.colorFormat = bayerFormat;
 558 #ifdef CAMERA_PACKED_BAYER_ENABLE
 559 #ifdef DEBUG_RAWDUMP
 560     if (m_parameters->checkBayerDumpEnable()) {
 561         /* packed bayer bytesPerPlane */
 562         pipeInfo[ispsNodeType].bytesPerPlane[0] = ROUND_UP(tempRect.fullW * 2, 16);
 563     }
 564     else
 565 #endif
 566     {
 567         /* packed bayer bytesPerPlane */
 568         pipeInfo[ispsNodeType].bytesPerPlane[0] = ROUND_UP(tempRect.fullW * 3 / 2, 16);
 569     }
 570 #endif
 571
 572     pipeInfo[ispsNodeType].rectInfo = tempRect;
 573     pipeInfo[ispsNodeType].bufInfo.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
 574     pipeInfo[ispsNodeType].bufInfo.memory = V4L2_CAMERA_MEMORY_TYPE;
 575     pipeInfo[ispsNodeType].bufInfo.count = config->current->bufInfo.num_3aa_buffers;
 576
 577     pipeInfo[ispsNodeType].perFrameNodeGroupInfo.perframeSupportNodeNum = 0;
 578     pipeInfo[ispsNodeType].perFrameNodeGroupInfo.perFrameLeaderInfo.perframeInfoIndex = PERFRAME_INFO_ISP;
 579     pipeInfo[ispsNodeType].perFrameNodeGroupInfo.perFrameLeaderInfo.perFrameNodeType = PERFRAME_NODE_TYPE_LEADER;
 580     pipeInfo[ispsNodeType].perFrameNodeGroupInfo.perFrameLeaderInfo.perFrameVideoID = (m_deviceInfo[INDEX(PIPE_3AA)].secondaryNodeNum[ispsNodeType] - FIMC_IS_VIDEO_BAS_NUM);
 581
 582     /* ISPC */
 583     enum NODE_TYPE ispcNodeType = getNodeType(PIPE_ISPC);
 584
 585     perFramePos = (m_cameraId == CAMERA_ID_BACK) ? PERFRAME_BACK_ISPC_POS : PERFRAME_FRONT_ISPC_POS;
 586     pipeInfo[t3asNodeType].perFrameNodeGroupInfo.perFrameCaptureInfo[perFramePos].perFrameNodeType = PERFRAME_NODE_TYPE_CAPTURE;
 587     pipeInfo[t3asNodeType].perFrameNodeGroupInfo.perFrameCaptureInfo[perFramePos].perFrameVideoID = (m_deviceInfo[PIPE_3AA].nodeNum[ispcNodeType] - FIMC_IS_VIDEO_BAS_NUM);
 588
 589     tempRect.fullW = bdsSize.w;
 590     tempRect.fullH = bdsSize.h;
 591     tempRect.colorFormat = hwVdisformat;
 592
 593 #ifdef USE_BUFFER_WITH_STRIDE
 594         /* to use stride for preview buffer, set the bytesPerPlane */
 595         pipeInfo[ispcNodeType].bytesPerPlane[0] = bdsSize.w;
 596 #endif
 597
 598     pipeInfo[ispcNodeType].rectInfo = tempRect;
 599     pipeInfo[ispcNodeType].bufInfo.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
 600     pipeInfo[ispcNodeType].bufInfo.memory = V4L2_CAMERA_MEMORY_TYPE;
 601     pipeInfo[ispcNodeType].bufInfo.count = config->current->bufInfo.num_hwdis_buffers;
 602
 603     pipeInfo[ispcNodeType].perFrameNodeGroupInfo.perframeSupportNodeNum = 0;
 604     pipeInfo[ispcNodeType].perFrameNodeGroupInfo.perFrameLeaderInfo.perFrameNodeType = PERFRAME_NODE_TYPE_NONE;
 605
 606     ret = m_pipes[INDEX(PIPE_3AA)]->setupPipe(pipeInfo, sensorIds, secondarySensorIds);
 607     if (ret < 0) {
 608         CLOGE("ERR(%s[%d]):3AA setupPipe fail, ret(%d)", __FUNCTION__, __LINE__, ret);
 609         /* TODO: exception handling */
 610         return INVALID_OPERATION;
 611     }
 612
 613     CLOGI("INFO(%s[%d]) OUT", __FUNCTION__, __LINE__);
 614     m_frameCount = 0;
 615
 616     return NO_ERROR;
 617 }
 618
 619 status_t ExynosCameraFrameFactoryFront::preparePipes(void)
 620 {
 621     int ret = 0;
 622
 623     /* NOTE: Prepare for 3AA is moved after ISP stream on */
 624
 625     if (m_requestFLITE) {
 626         ret = m_pipes[INDEX(PIPE_FLITE)]->prepare();
 627         if (ret < 0) {
 628             CLOGE("ERR(%s[%d]):FLITE prepare fail, ret(%d)", __FUNCTION__, __LINE__, ret);
 629             /* TODO: exception handling */
 630             return INVALID_OPERATION;
 631         }
 632     }
 633
 634     if (m_supportSCC == true) {
 635         enum pipeline pipe = (m_supportSCC == true) ? PIPE_SCC : PIPE_ISPC;
 636
 637         ret = m_pipes[INDEX(pipe)]->prepare();
 638         if (ret < 0) {
 639             CLOGE("ERR(%s[%d]):%s prepare fail, ret(%d)", __FUNCTION__, __LINE__, m_pipes[INDEX(pipe)]->getPipeName(), ret);
 640             /* TODO: exception handling */
 641             return INVALID_OPERATION;
 642         }
 643     }
 644
 645     return NO_ERROR;
 646 }
 647
 648 status_t ExynosCameraFrameFactoryFront::startPipes(void)
 649 {
 650     int ret = 0;
 651
 652     if (m_supportSCC == true) {
 653         enum pipeline pipe = (m_supportSCC == true) ? PIPE_SCC : PIPE_ISPC;
 654
 655         ret = m_pipes[INDEX(pipe)]->start();
 656         if (ret < 0) {
 657             CLOGE("ERR(%s[%d]):%s start fail, ret(%d)", __FUNCTION__, __LINE__, m_pipes[INDEX(pipe)]->getPipeName(), ret);
 658             /* TODO: exception handling */
 659             return INVALID_OPERATION;
 660         }
 661     }
 662
 663     if (m_flag3aaIspOTF == false) {
 664         ret = m_pipes[INDEX(PIPE_ISP)]->start();
 665         if (ret < 0) {
 666             CLOGE("ERR(%s[%d]):ISP start fail, ret(%d)", __FUNCTION__, __LINE__, ret);
 667             /* TODO: exception handling */
 668             return INVALID_OPERATION;
 669         }
 670     }
 671
 672     ret = m_pipes[INDEX(PIPE_3AA)]->start();
 673     if (ret < 0) {
 674         CLOGE("ERR(%s[%d]):3AA start fail, ret(%d)", __FUNCTION__, __LINE__, ret);
 675         /* TODO: exception handling */
 676         return INVALID_OPERATION;
 677     }
 678
 679     ret = m_pipes[INDEX(PIPE_FLITE)]->start();
 680     if (ret < 0) {
 681         CLOGE("ERR(%s[%d]):FLITE start fail, ret(%d)", __FUNCTION__, __LINE__, ret);
 682         /* TODO: exception handling */
 683         return INVALID_OPERATION;
 684     }
 685
 686     if (m_flagFlite3aaOTF == true) {
 687         /* Here is doing 3AA prepare(qbuf) */
 688         ret = m_pipes[INDEX(PIPE_3AA)]->prepare();
 689         if (ret < 0) {
 690             CLOGE("ERR(%s[%d]):3AA prepare fail, ret(%d)", __FUNCTION__, __LINE__, ret);
 691             /* TODO: exception handling */
 692             return INVALID_OPERATION;
 693         }
 694     }
 695
 696     ret = m_pipes[INDEX(PIPE_FLITE)]->sensorStream(true);
 697     if (ret < 0) {
 698         CLOGE("ERR(%s[%d]):FLITE sensorStream on fail, ret(%d)", __FUNCTION__, __LINE__, ret);
 699         /* TODO: exception handling */
 700         return INVALID_OPERATION;
 701     }
 702
 703     CLOGI("INFO(%s[%d]):Starting Success!", __FUNCTION__, __LINE__);
 704
 705     return NO_ERROR;
 706 }
 707
 708 status_t ExynosCameraFrameFactoryFront::startInitialThreads(void)
 709 {
 710     int ret = 0;
 711
 712     CLOGI("INFO(%s[%d]):start pre-ordered initial pipe thread", __FUNCTION__, __LINE__);
 713
 714     if (m_requestFLITE) {
 715         ret = startThread(PIPE_FLITE);
 716         if (ret < 0)
 717             return ret;
 718     }
 719
 720     ret = startThread(PIPE_3AA);
 721     if (ret < 0)
 722         return ret;
 723
 724     if (m_flag3aaIspOTF == false) {
 725         ret = startThread(PIPE_ISP);
 726         if (ret < 0)
 727             return ret;
 728     }
 729
 730     if (m_parameters->getTpuEnabledMode() == true) {
 731         ret = startThread(PIPE_DIS);
 732         if (ret < 0)
 733             return ret;
 734     }
 735
 736     if(m_supportSCC) {
 737         enum pipeline pipe = (m_supportSCC == true) ? PIPE_SCC : PIPE_ISPC;
 738
 739         ret = startThread(pipe);
 740         if (ret < 0)
 741             return ret;
 742     }
 743
 744     return NO_ERROR;
 745 }
 746
 747 status_t ExynosCameraFrameFactoryFront::setStopFlag(void)
 748 {
 749     CLOGI("INFO(%s[%d]):", __FUNCTION__, __LINE__);
 750
 751     int ret = 0;
 752
 753     ret = m_pipes[INDEX(PIPE_FLITE)]->setStopFlag();
 754
 755     if (m_pipes[INDEX(PIPE_3AA)]->flagStart() == true)
 756         ret = m_pipes[INDEX(PIPE_3AA)]->setStopFlag();
 757
 758     if (m_pipes[INDEX(PIPE_ISP)]->flagStart() == true)
 759         ret = m_pipes[INDEX(PIPE_ISP)]->setStopFlag();
 760
 761     if (m_supportSCC == true) {
 762         enum pipeline pipe = (m_supportSCC == true) ? PIPE_SCC : PIPE_ISPC;
 763
 764         ret = m_pipes[INDEX(pipe)]->setStopFlag();
 765     }
 766
 767     return NO_ERROR;
 768 }
 769
 770 status_t ExynosCameraFrameFactoryFront::stopPipes(void)
 771 {
 772     int ret = 0;
 773     if (m_supportSCC == true) {
 774         enum pipeline pipe = (m_supportSCC == true) ? PIPE_SCC : PIPE_ISPC;
 775
 776         ret = m_pipes[INDEX(pipe)]->stopThread();
 777         if (ret < 0) {
 778             CLOGE("ERR(%s[%d]):%s stopThread fail, ret(%d)", __FUNCTION__, __LINE__, m_pipes[INDEX(pipe)]->getPipeName(), ret);
 779             /* TODO: exception handling */
 780             return INVALID_OPERATION;
 781         }
 782     }
 783
 784     if (m_pipes[INDEX(PIPE_3AA)]->isThreadRunning() == true) {
 785         ret = m_pipes[INDEX(PIPE_3AA)]->stopThread();
 786         if (ret < 0) {
 787             CLOGE("ERR(%s[%d]):3AA stopThread fail, ret(%d)", __FUNCTION__, __LINE__, ret);
 788             /* TODO: exception handling */
 789             return INVALID_OPERATION;
 790         }
 791     }
 792
 793     /* stream off for ISP */
 794     if (m_pipes[INDEX(PIPE_ISP)]->isThreadRunning() == true) {
 795         ret = m_pipes[INDEX(PIPE_ISP)]->stopThread();
 796         if (ret < 0) {
 797             CLOGE("ERR(%s[%d]):ISP stopThread fail, ret(%d)", __FUNCTION__, __LINE__, ret);
 798             /* TODO: exception handling */
 799             return INVALID_OPERATION;
 800         }
 801     }
 802
 803     if (m_requestFLITE) {
 804         ret = m_pipes[INDEX(PIPE_FLITE)]->stopThread();
 805         if (ret < 0) {
 806             CLOGE("ERR(%s[%d]):FLITE stopThread fail, ret(%d)", __FUNCTION__, __LINE__, ret);
 807             /* TODO: exception handling */
 808             return INVALID_OPERATION;
 809         }
 810     }
 811
 812     if (m_pipes[INDEX(PIPE_GSC)]->isThreadRunning() == true) {
 813         ret = stopThread(INDEX(PIPE_GSC));
 814         if (ret < 0) {
 815             CLOGE("ERR(%s[%d]):PIPE_GSC stopThread fail, ret(%d)", __FUNCTION__, __LINE__, ret);
 816             return INVALID_OPERATION;
 817         }
 818     }
 819     ret = m_pipes[INDEX(PIPE_FLITE)]->sensorStream(false);
 820     if (ret < 0) {
 821         CLOGE("ERR(%s[%d]):FLITE sensorStream off fail, ret(%d)", __FUNCTION__, __LINE__, ret);
 822         /* TODO: exception handling */
 823         return INVALID_OPERATION;
 824     }
 825
 826     ret = m_pipes[INDEX(PIPE_FLITE)]->stop();
 827     if (ret < 0) {
 828         CLOGE("ERR(%s[%d]):FLITE stop fail, ret(%d)", __FUNCTION__, __LINE__, ret);
 829         /* TODO: exception handling */
 830         return INVALID_OPERATION;
 831     }
 832
 833     /* 3AA force done */
 834     ret = m_pipes[INDEX(PIPE_3AA)]->forceDone(V4L2_CID_IS_FORCE_DONE, 0x1000);
 835     if (ret < 0) {
 836         CLOGE("ERR(%s[%d]):PIPE_3AA force done fail, ret(%d)", __FUNCTION__, __LINE__, ret);
 837         /* TODO: exception handling */
 838         /* return INVALID_OPERATION; */
 839     }
 840
 841     /* stream off for 3AA */
 842     ret = m_pipes[INDEX(PIPE_3AA)]->stop();
 843     if (ret < 0) {
 844         CLOGE("ERR(%s[%d]):3AA stop fail, ret(%d)", __FUNCTION__, __LINE__, ret);
 845         /* TODO: exception handling */
 846         return INVALID_OPERATION;
 847     }
 848
 849     /* ISP force done */
 850     if (m_pipes[INDEX(PIPE_ISP)]->flagStart() == true) {
 851         ret = m_pipes[INDEX(PIPE_ISP)]->forceDone(V4L2_CID_IS_FORCE_DONE, 0x1000);
 852         if (ret < 0) {
 853             CLOGE("ERR(%s[%d]):PIPE_ISP force done fail, ret(%d)", __FUNCTION__, __LINE__, ret);
 854             /* TODO: exception handling */
 855             /* return INVALID_OPERATION; */
 856         }
 857
 858         /* stream off for ISP */
 859         ret = m_pipes[INDEX(PIPE_ISP)]->stop();
 860         if (ret < 0) {
 861             CLOGE("ERR(%s[%d]):ISP stop fail, ret(%d)", __FUNCTION__, __LINE__, ret);
 862             /* TODO: exception handling */
 863             return INVALID_OPERATION;
 864         }
 865     }
 866
 867     if (m_supportSCC == true) {
 868         enum pipeline pipe = (m_supportSCC == true) ? PIPE_SCC : PIPE_ISPC;
 869
 870         ret = m_pipes[INDEX(pipe)]->stop();
 871         if (ret < 0) {
 872             CLOGE("ERR(%s[%d]):%s stop fail, ret(%d)", __FUNCTION__, __LINE__, m_pipes[INDEX(pipe)]->getPipeName(), ret);
 873             /* TODO: exception handling */
 874             return INVALID_OPERATION;
 875         }
 876     }
 877
 878     ret = stopThreadAndWait(INDEX(PIPE_GSC));
 879     if (ret < 0) {
 880         CLOGE("ERR(%s[%d]):PIPE_GSC stopThreadAndWait fail, ret(%d)", __FUNCTION__, __LINE__, ret);
 881     }
 882     CLOGI("INFO(%s[%d]):Stopping  Success!", __FUNCTION__, __LINE__);
 883
 884     return NO_ERROR;
 885 }
 886
 887 void ExynosCameraFrameFactoryFront::m_init(void)
 888 {
 889     m_supportReprocessing = false;
 890     m_flagFlite3aaOTF = false;
 891     m_supportSCC = false;
 892     m_supportPureBayerReprocessing = false;
 893     m_flagReprocessing = false;
 894     m_requestISP = 0;
 895 }
 896
 897 status_t ExynosCameraFrameFactoryFront::m_setupConfig()
 898 {
 899     CLOGI("INFO(%s[%d])", __FUNCTION__, __LINE__);
 900
 901     status_t ret = NO_ERROR;
 902
 903     int32_t *nodeNums = NULL;
 904     int32_t *controlId = NULL;
 905     int32_t *secondaryControlId = NULL;
 906     int32_t *prevNode = NULL;
 907
 908     enum NODE_TYPE nodeType = INVALID_NODE;
 909     int pipeId = -1;
 910
 911     int t3aaNums[MAX_NODE];
 912     int ispNums[MAX_NODE];
 913
 914     m_flagFlite3aaOTF = (m_cameraId == CAMERA_ID_BACK)?MAIN_CAMERA_DUAL_FLITE_3AA_OTF:FRONT_CAMERA_DUAL_FLITE_3AA_OTF;
 915     m_flag3aaIspOTF = (m_cameraId == CAMERA_ID_BACK)?MAIN_CAMERA_DUAL_3AA_ISP_OTF:FRONT_CAMERA_DUAL_3AA_ISP_OTF;
 916     m_supportReprocessing = m_parameters->isReprocessing();
 917     m_supportSCC = m_parameters->isOwnScc(m_cameraId);
 918     m_supportPureBayerReprocessing = (m_cameraId == CAMERA_ID_BACK) ? USE_PURE_BAYER_REPROCESSING_ON_DUAL : USE_PURE_BAYER_REPROCESSING_FRONT_ON_DUAL;
 919
 920     m_flagReprocessing = false;
 921
 922     if (m_supportReprocessing == false) {
 923         if (m_supportSCC == true)
 924             m_requestSCC = 1;
 925         else
 926             m_requestISPC = 1;
 927     }
 928
 929     if (m_flag3aaIspOTF == true)
 930         m_request3AP = 0;
 931     else
 932         m_request3AP = 1;
 933
 934     nodeNums = m_nodeNums[INDEX(PIPE_FLITE)];
 935     nodeNums[OUTPUT_NODE] = -1;
 936     nodeNums[CAPTURE_NODE_1] = (m_cameraId == CAMERA_ID_BACK) ? MAIN_CAMERA_FLITE_NUM : FRONT_CAMERA_FLITE_NUM;
 937     nodeNums[CAPTURE_NODE_2] = -1;
 938     controlId = m_sensorIds[INDEX(PIPE_FLITE)];
 939     controlId[CAPTURE_NODE_1] = m_getSensorId(nodeNums[CAPTURE_NODE_1], m_flagReprocessing);
 940     prevNode = nodeNums;
 941
 942 #if 1
 943     t3aaNums[OUTPUT_NODE]    = FIMC_IS_VIDEO_30S_NUM;
 944     t3aaNums[CAPTURE_NODE_1] = -1;
 945     t3aaNums[CAPTURE_NODE_2] = FIMC_IS_VIDEO_30P_NUM;
 946 #else
 947     t3aaNums[OUTPUT_NODE]    = FIMC_IS_VIDEO_31S_NUM;
 948     t3aaNums[CAPTURE_NODE_1] = -1;
 949     t3aaNums[CAPTURE_NODE_2] = FIMC_IS_VIDEO_31P_NUM;
 950 #endif
 951     ispNums[OUTPUT_NODE]    = FIMC_IS_VIDEO_I1S_NUM;
 952     ispNums[CAPTURE_NODE_1] = -1;
 953     ispNums[CAPTURE_NODE_2] = FIMC_IS_VIDEO_I1C_NUM;
 954
 955     /* 1. 3AAS */
 956     pipeId = INDEX(PIPE_3AA);
 957     nodeType = getNodeType(PIPE_3AA);
 958     m_deviceInfo[pipeId].nodeNum[nodeType] = t3aaNums[OUTPUT_NODE];
 959     strncpy(m_deviceInfo[pipeId].nodeName[nodeType], "3AA_OUTPUT", EXYNOS_CAMERA_NAME_STR_SIZE - 1);
 960     m_sensorIds[pipeId][nodeType]  = m_getSensorId(m_nodeNums[INDEX(PIPE_FLITE)][getNodeType(PIPE_FLITE)], m_flagFlite3aaOTF, true, m_flagReprocessing);
 961     m_deviceInfo[pipeId].pipeId[nodeType]  = PIPE_3AA;
 962
 963
 964     /* 2. 3AAP */
 965     nodeType = getNodeType(PIPE_3AP);
 966     m_deviceInfo[pipeId].secondaryNodeNum[nodeType] = t3aaNums[CAPTURE_NODE_2];
 967     strncpy(m_deviceInfo[pipeId].secondaryNodeName[nodeType], "3AA_PREVIEW", EXYNOS_CAMERA_NAME_STR_SIZE - 1);
 968     m_secondarySensorIds[pipeId][nodeType] = -1;
 969     m_secondarySensorIds[pipeId][nodeType] = m_getSensorId(m_deviceInfo[pipeId].nodeNum[getNodeType(PIPE_3AA)], true, false, m_flagReprocessing);
 970     m_deviceInfo[pipeId].pipeId[nodeType] = PIPE_3AP;
 971
 972     /* 3. ISPS */
 973     nodeType = getNodeType(PIPE_ISP);
 974     m_deviceInfo[pipeId].secondaryNodeNum[nodeType] = ispNums[OUTPUT_NODE];
 975     strncpy(m_deviceInfo[pipeId].secondaryNodeName[nodeType], "ISP_OUTPUT", EXYNOS_CAMERA_NAME_STR_SIZE - 1);
 976     m_secondarySensorIds[pipeId][nodeType] = m_getSensorId(m_deviceInfo[pipeId].secondaryNodeNum[getNodeType(PIPE_3AP)], m_flag3aaIspOTF, false, m_flagReprocessing);
 977     m_deviceInfo[pipeId].pipeId[nodeType] = PIPE_ISP;
 978
 979     // ISPC
 980     nodeType = getNodeType(PIPE_ISPC);
 981     m_deviceInfo[pipeId].nodeNum[nodeType] = ispNums[CAPTURE_NODE_2];
 982     strncpy(m_deviceInfo[pipeId].nodeName[nodeType], "ISP_PREVIEW", EXYNOS_CAMERA_NAME_STR_SIZE - 1);
 983     m_sensorIds[pipeId][nodeType]  = -1;
 984     m_sensorIds[pipeId][nodeType]  = m_getSensorId(m_deviceInfo[pipeId].nodeNum[getNodeType(PIPE_ISP)], true, false, m_flagReprocessing);
 985     m_deviceInfo[pipeId].pipeId[nodeType]  = PIPE_ISPC;
 986
 987     nodeNums = m_nodeNums[INDEX(PIPE_GSC)];
 988     nodeNums[OUTPUT_NODE] = PREVIEW_GSC_NODE_NUM;
 989     nodeNums[CAPTURE_NODE_1] = -1;
 990     nodeNums[CAPTURE_NODE_2] = -1;
 991
 992     nodeNums = m_nodeNums[INDEX(PIPE_GSC_VIDEO)];
 993     nodeNums[OUTPUT_NODE] = VIDEO_GSC_NODE_NUM;
 994     nodeNums[CAPTURE_NODE_1] = -1;
 995     nodeNums[CAPTURE_NODE_2] = -1;
 996
 997     nodeNums = m_nodeNums[INDEX(PIPE_GSC_PICTURE)];
 998     nodeNums[OUTPUT_NODE] = PICTURE_GSC_NODE_NUM;
 999     nodeNums[CAPTURE_NODE_1] = -1;
1000     nodeNums[CAPTURE_NODE_2] = -1;
1001
1002     nodeNums = m_nodeNums[INDEX(PIPE_JPEG)];
1003     nodeNums[OUTPUT_NODE] = -1;
1004     nodeNums[CAPTURE_NODE_1] = -1;
1005     nodeNums[CAPTURE_NODE_2] = -1;
1006
1007     for (int i = 0; i < MAX_NODE; i++)
1008         m_nodeNums[pipeId][i] = m_deviceInfo[pipeId].nodeNum[i];
1009
1010     if (m_checkNodeSetting(pipeId) != NO_ERROR) {
1011         CLOGE("ERR(%s[%d]):m_checkNodeSetting(%d) fail", __FUNCTION__, __LINE__, pipeId);
1012         return INVALID_OPERATION;
1013     }
1014
1015     return NO_ERROR;
1016 }
1017
1018 enum NODE_TYPE  ExynosCameraFrameFactoryFront::getNodeType(uint32_t pipeId)
1019 {
1020     enum NODE_TYPE nodeType = INVALID_NODE;
1021
1022     switch (pipeId) {
1023     case PIPE_FLITE:
1024         nodeType = CAPTURE_NODE_1;
1025         break;
1026     case PIPE_3AA:
1027         nodeType = OUTPUT_NODE;
1028         break;
1029     case PIPE_ISPC:
1030         nodeType = CAPTURE_NODE_1;
1031         break;
1032     case PIPE_3AP:
1033         nodeType = CAPTURE_NODE_2;
1034         break;
1035     case PIPE_3AC:
1036         nodeType = CAPTURE_NODE_3;
1037         break;
1038     case PIPE_ISP:
1039         nodeType = OTF_NODE_1;
1040         break;
1041     case PIPE_ISPP:
1042         nodeType = CAPTURE_NODE_5;
1043         break;
1044     case PIPE_JPEG:
1045         nodeType = CAPTURE_NODE_6;
1046         break;
1047     case PIPE_SCP:
1048         nodeType = CAPTURE_NODE_7;
1049         break;
1050     default:
1051         android_printAssert(NULL, LOG_TAG, "ASSERT(%s[%d]):Unexpected pipe_id(%d), assert!!!!",
1052             __FUNCTION__, __LINE__, pipeId);
1053         break;
1054     }
1055
1056     return nodeType;
1057 }
1058
1059 }; /* namespace android */