/*
 * Copyright (C) 2019 MediaTek Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef CAMERA_HAL_MEDIATEK_MTKCAM_PIPELINE_HWNODE_P1_P1COMMON_H_
#define CAMERA_HAL_MEDIATEK_MTKCAM_PIPELINE_HWNODE_P1_P1COMMON_H_
//
#include <sys/prctl.h>
#include <sys/resource.h>
#include <atomic>
#include <list>
#include <queue>
#include <string>
#include <thread>
#include <vector>
//
#include "P1Config.h"  // buildup configuration
//
#include <mtkcam/def/PriorityDefs.h>
//
#include <ImageDesc.h>
#include <mtkcam/utils/std/Log.h>
#include <mtkcam/utils/std/common.h>
#include <mtkcam/utils/std/DebugScanLine.h>
//
#include <mtkcam/utils/metadata/hal/mtk_platform_metadata_tag.h>
#include <mtkcam/utils/metadata/client/mtk_metadata_tag.h>
//
#include <mtkcam/utils/metadata/mtk_metadata_types.h>
//
#include <mtkcam/utils/metastore/IMetadataProvider.h>
//
#include <mtkcam/utils/imgbuf/IGbmImageBufferHeap.h>
//
#if (P1NODE_USING_DRV_IO_PIPE_EVENT > 0)
#include <mtkcam/drv/iopipe/Event/IoPipeEvent.h>
#endif
#include <mtkcam/drv/iopipe/CamIO/Cam_Notify.h>
#include <mtkcam/drv/iopipe/CamIO/Cam_QueryDef.h>
#include <mtkcam/drv/iopipe/CamIO/V4L2IHalCamIO.h>
#include <mtkcam/drv/iopipe/CamIO/V4L2IIOPipe.h>
#if (P1NODE_SUPPORT_RSS > 0)
#include <mtkcam/drv/iopipe/CamIO/rss_cb.h>
#endif
#include <mtkcam/aaa/IHal3A.h>
#include <mtkcam/aaa/lcs/lcs_hal.h>
//
//
#include <mtkcam/pipeline/hwnode/P1Node.h>
#include <mtkcam/pipeline/stream/IStreamBuffer.h>
#include <mtkcam/pipeline/stream/IStreamInfo.h>
#include <mtkcam/pipeline/utils/streambuf/IStreamBufferPool.h>
//
#include <mtkcam/utils/hw/GyroCollector.h>
#include <mtkcam/utils/hw/HwInfoHelper.h>
#include <mtkcam/utils/hw/IResourceConcurrency.h>
#if (P1NODE_SUPPORT_BUFFER_TUNING_DUMP > 0)
#include <mtkcam/utils/TuningUtils/FileDumpNamingRule.h>
#endif
//
#include "../BaseNode.h"
#include "../MyUtils.h"
#include "../Profile.h"
#include <compiler.h>
//

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
namespace NSCam {
namespace v3 {
namespace NSP1Node {

/******************************************************************************
 *
 ******************************************************************************/
#define SUPPORT_3A (P1NODE_SUPPORT_3A)
#define SUPPORT_ISP (P1NODE_SUPPORT_ISP)
#define SUPPORT_PERFRAME_CTRL (P1NODE_SUPPORT_PERFRAME_CTRL)
//
#define SUPPORT_LCS (P1NODE_SUPPORT_LCS)
#define SUPPORT_RSS (P1NODE_SUPPORT_RSS)
#define SUPPORT_FSC (P1NODE_SUPPORT_FSC)

//
#define SUPPORT_RRZ_DST_CTRL (P1NODE_SUPPORT_RRZ_DST_CTRL)

//
#define SUPPORT_CONFIRM_BUF_PA (P1NODE_SUPPORT_CONFIRM_BUF_PA)
#define SUPPORT_CONFIRM_BUF_PA_VA (P1NODE_SUPPORT_CONFIRM_BUF_PA_VA)

//
#define SUPPORT_BUFFER_TUNING_DUMP (P1NODE_SUPPORT_BUFFER_TUNING_DUMP)

//
#define USING_CTRL_3A_LIST (P1NODE_USING_CTRL_3A_LIST)
#define USING_CTRL_3A_LIST_PREVIOUS \
  (P1NODE_USING_CTRL_3A_LIST_PREVIOUS)  // USING_PREVIOUS_3A_LIST

//
#define USING_DRV_SET_RRZ_CBFP_EXP_SKIP (P1NODE_USING_DRV_SET_RRZ_CBFP_EXP_SKIP)
#define USING_DRV_QUERY_CAPABILITY_EXP_SKIP \
  (P1NODE_USING_DRV_QUERY_CAPABILITY_EXP_SKIP)

//
#define USING_DRV_IO_PIPE_EVENT (P1NODE_USING_DRV_IO_PIPE_EVENT)

//
#define ENABLE_CHECK_CONFIG_COMMON_PORPERTY \
  (P1NODE_ENABLE_CHECK_CONFIG_COMMON_PORPERTY)

/******************************************************************************
 *
 ******************************************************************************/
#define IS_P1_LOGI \
  (MTKCAM_HW_NODE_LOG_LEVEL_DEFAULT >= 2)  // for system use LOGI
#define IS_P1_LOGD \
  (MTKCAM_HW_NODE_LOG_LEVEL_DEFAULT >= 3)  // for system use LOGD
#define P1_LOG_LEN (256)

#define P1_SUPPORT_DIR_RESTREAM (1)
#define P1_LOG_NOTE_TAG "[::P1_LOG_NOTE::]"
#define P1_LOG_DUMP_TAG "[::P1_LOG_DUMP::]"
#define P1_LOG_LINE_BGN                  \
  " ++++++++ ++++++++ ++++++++ ++++++++" \
  " ++++++++ ++++++++ ++++++++ ++++++++" \
  " ++++++++ ++++++++ ++++++++ ++++++++" \
  " ++++++++ ++++++++ ++++++++ ++++++++"
#define P1_LOG_LINE_END                  \
  " -------- -------- -------- --------" \
  " -------- -------- -------- --------" \
  " -------- -------- -------- --------" \
  " -------- -------- -------- --------"

#define P1_LOG                                                                 \
  char strLog[P1_LOG_LEN] = {0};                                               \
  snprintf(strLog, P1_LOG_LEN, "Cam::%d R%d S%d E%d D%d O%d #%d", getOpenId(), \
           mTagReq.get(), mTagSet.get(), mTagEnq.get(), mTagDeq.get(),         \
           mTagOut.get(), mTagList.get());

/* P1_LOGD only use in P1NodeImp */
#if (IS_P1_LOGI)  // for system use LOGI
#define P1_LOGI(lv, fmt, arg...)                               \
  do {                                                         \
    if (mLogLevelI >= lv) {                                    \
      P1_LOG;                                                  \
      CAM_LOGI("[%s] [%s] " fmt, __FUNCTION__, strLog, ##arg); \
    }                                                          \
  } while (0)
#else
#define P1_LOGI(lv, fmt, arg...)
#endif

/* P1_LOGD only use in P1NodeImp */
#if (IS_P1_LOGD)  // for system use LOGD
#define P1_LOGD(lv, fmt, arg...)                               \
  do {                                                         \
    if (mLogLevel >= lv) {                                     \
      P1_LOG;                                                  \
      CAM_LOGD("[%s] [%s] " fmt, __FUNCTION__, strLog, ##arg); \
    }                                                          \
  } while (0)
#else
#define P1_LOGD(lv, fmt, arg...)
#endif

//
#define P1_SYS_LV_OFF (0)
#define P1_SYS_LV_BASIC (1)
#define P1_SYS_LV_CRITICAL (2)
#define P1_SYS_LV_DEFAULT (3)
#define P1_SYS_LV_VERBOSE (4)
#define P1_ATRACE_ENABLED() (0)

#define P1_CAM_TRACE_NAME_LENGTH 128
#define P1_CAM_TRACE_FMT_BEGIN(fmt, arg...)                \
  do {                                                     \
    if (CC_UNLIKELY(P1_ATRACE_ENABLED())) {                \
      char buf[P1_CAM_TRACE_NAME_LENGTH] = {0};            \
      snprintf(buf, P1_CAM_TRACE_NAME_LENGTH, fmt, ##arg); \
      CAM_TRACE_BEGIN(buf);                                \
    }                                                      \
  } while (0)

#define P1_CAM_TRACE_BEGIN(str)             \
  do {                                      \
    if (CC_UNLIKELY(P1_ATRACE_ENABLED())) { \
      CAM_TRACE_BEGIN(str);                 \
    }                                       \
  } while (0)

#define P1_CAM_TRACE_END()                  \
  do {                                      \
    if (CC_UNLIKELY(P1_ATRACE_ENABLED())) { \
      CAM_TRACE_END();                      \
    }                                       \
  } while (0)

#define P1_TRACE_S_BEGIN(lv, str) \
  do {                            \
    if (mSysLevel >= lv) {        \
      P1_CAM_TRACE_BEGIN(str);    \
    }                             \
  } while (0)

#define P1_TRACE_F_BEGIN(lv, fmt, arg...) \
  do {                                    \
    if (mSysLevel >= lv) {                \
      P1_CAM_TRACE_FMT_BEGIN(fmt, ##arg); \
    }                                     \
  } while (0)

#define P1_TRACE_C_END(lv) \
  do {                     \
    if (mSysLevel >= lv) { \
      P1_CAM_TRACE_END();  \
    }                      \
  } while (0)

class P1AutoTrace {
 public:
  inline P1AutoTrace(MINT32 sysLv, MINT32 tagLv, const char* name)
      : mExe((sysLv >= tagLv) && (P1_ATRACE_ENABLED())) {
    if (CC_UNLIKELY(mExe)) {
      CAM_TRACE_BEGIN(name);
    }
  }

  inline ~P1AutoTrace() {
    if (CC_UNLIKELY(mExe)) {
      CAM_TRACE_END();
    }
  }

 private:
  MBOOL mExe;
};

#define P1_TRACE_AUTO(lv, name) P1AutoTrace _auto_trace(mSysLevel, lv, name)

#define P1_TRACE_FUNC(lv) P1_TRACE_AUTO(lv, __FUNCTION__)

#define P1_TRACE_INT(lv, name, value)                              \
  do {                                                             \
    if (CC_UNLIKELY((mSysLevel >= lv) && (P1_ATRACE_ENABLED()))) { \
      CAM_TRACE_INT(name, value);                                  \
    }                                                              \
  } while (0)

//

#define P1THREAD_POLICY (SCHED_OTHER)
#define P1THREAD_PRIORITY \
  (NICE_CAMERA_PIPELINE_P1NODE)  // (ANDROID_PRIORITY_FOREGROUND-2)

#define P1SOFIDX_INIT_VAL (0)
#define P1SOFIDX_LAST_VAL (0xFF)
#define P1SOFIDX_NULL_VAL (0xFFFFFFFF)

#define P1_QUE_ID_NULL ((MINT32)(0))
#define P1_QUE_ID_FIRST ((MINT32)(1))
#define P1_MAGIC_NUM_INVALID ((MINT32)(-1))
#define P1_MAGIC_NUM_NULL ((MINT32)(0))
#define P1_MAGIC_NUM_FIRST ((MINT32)(1))
#define P1_FRM_NUM_NULL ((MINT32)(-1))
#define P1_REQ_NUM_NULL ((MINT32)(-1))

#define P1GET_FRM_NUM(frame) \
  ((frame == NULL) ? P1_FRM_NUM_NULL : frame->getFrameNo())
#define P1GET_REQ_NUM(frame) \
  ((frame == NULL) ? P1_REQ_NUM_NULL : frame->getRequestNo())

#if 0  // simple
#define P1NUM_ACT_STR "[%d](%d)(%d:%d)@(%d)"
#define P1INFO_ACT_STR \
  P1NUM_ACT_STR        \
  "[T:%d O:x%X R:x%X C:%d E:%d F:x%X]"
#else
#define P1NUM_ACT_STR "[Num Q:%d M:%d F:%d R:%d @%d]"
#define P1INFO_ACT_STR \
  P1NUM_ACT_STR        \
  "[Type:%d Out:x%X Rec:x%X Raw:%d Cap:%d Exe:%d Flush:x%X]"
#endif
#define P1NUM_ACT_VAR(act) \
  (act).queId, (act).magicNum, (act).frmNum, (act).reqNum, (act).sofIdx
#define P1INFO_ACT_VAR(act)                                         \
  P1NUM_ACT_VAR(act), (act).reqType, (act).reqOutSet, (act).expRec, \
      (act).fullRawType, (act).capType, (act).exeState, (act).flushSet

// #define P1INFO_ACT(LOG_LEVEL, act) MY_LOGD##LOG_LEVEL(\
//    P1INFO_ACT_STR, P1INFO_ACT_VAR(act));

#define P1INFO_STREAM_STR "StreamID(%#" PRIx64 ")[%s_%d] "

#define P1INFO_STREAM_VAR(T)                                          \
  (((mpP1NodeImp == nullptr) ||                                       \
    ((stream##T) >= (sizeof(mpP1NodeImp->mvStream##T) /               \
                     sizeof(mpP1NodeImp->mvStream##T[0]))) ||         \
    (mpP1NodeImp->mvStream##T[stream##T] == nullptr))                 \
       ? ((StreamId_T)(-1))                                           \
       : (mpP1NodeImp->mvStream##T[stream##T]->getStreamId())),       \
      (((mpP1NodeImp == nullptr) ||                                   \
        ((stream##T) >= (sizeof(mpP1NodeImp->maStream##T##Name) /     \
                         sizeof(mpP1NodeImp->maStream##T##Name[0])))) \
           ? ("UNKNOWN")                                              \
           : (mpP1NodeImp->maStream##T##Name[stream##T])),            \
      stream##T

#define P1INFO_STREAM_IMG_STR \
  P1INFO_STREAM_STR           \
  "[ImgBuf:%p-H:%p SB:%p L:%d T:%d]"
#define P1INFO_STREAM_IMG_VAR(act)                                      \
  P1INFO_STREAM_VAR(Img), (act).streamBufImg[streamImg].spImgBuf.get(), \
      (((act).streamBufImg[streamImg].spImgBuf != nullptr)              \
           ? ((act)                                                     \
                  .streamBufImg[streamImg]                              \
                  .spImgBuf->getImageBufferHeap()                       \
                  .get())                                               \
           : (nullptr)),                                                \
      (act).streamBufImg[streamImg].spStreamBuf.get(),                  \
      (act).streamBufImg[streamImg].eLockState,                         \
      (act).streamBufImg[streamImg].eSrcType

#define P1_CHECK_STREAM_SET(TYPE, stream)                               \
  if (CC_UNLIKELY(stream < (STREAM_##TYPE)STREAM_ITEM_START ||          \
                  stream >= STREAM_##TYPE##_NUM)) {                     \
    MY_LOGE("stream index invalid %d/%d", stream, STREAM_##TYPE##_NUM); \
    return INVALID_OPERATION;                                           \
  }

#define P1_CHECK_CFG_STREAM(TYPE, act, stream)                             \
  if (CC_UNLIKELY((act).mpP1NodeImp == nullptr ||                          \
                  (act).mpP1NodeImp->mvStream##TYPE[stream] == nullptr)) { \
    MY_LOGW("StreamId is NULL %d@%d", stream, (act).magicNum);             \
    return BAD_VALUE;                                                      \
  }

#define P1_CHECK_MAP_STREAM(TYPE, act, stream)                       \
  if (CC_UNLIKELY((act).appFrame == nullptr)) {                      \
    MY_LOGW("pipeline frame is NULL %d@%d", stream, (act).magicNum); \
    return INVALID_OPERATION;                                        \
  }                                                                  \
  P1_CHECK_CFG_STREAM(TYPE, (act), stream);                          \
  if (CC_UNLIKELY(!(act).streamBuf##TYPE[stream].bExist)) {          \
    MY_LOGD("stream is not exist %d@%d", stream, (act).magicNum);    \
    return OK;                                                       \
  }
//
#define P1_PORT_TO_STR(PortID)                                   \
  ((PortID.index == PORT_RRZO.index)                             \
       ? "RRZ"                                                   \
       : ((PortID.index == PORT_IMGO.index)                      \
              ? "IMG"                                            \
              : ((PortID.index == PORT_LCSO.index)               \
                     ? "LCS"                                     \
                     : ((PortID.index == PORT_RSSO.index)        \
                            ? "RSS"                              \
                            : ((PortID.index == PORT_EISO.index) \
                                   ? "EIS"                       \
                                   : "UNKNOWN")))))
//
#define P1_RECT_STR "(%d,%d_%dx%d) "
#define P1_RECT_VAR(rect) rect.p.x, rect.p.y, rect.s.w, rect.s.h
#define P1_SIZE_STR "(%dx%d) "
#define P1_SIZE_VAR(size) size.w, size.h
#define P1_STREAM_NAME_LEN (16)

#define EN_BURST_MODE (mBurstNum > 1)
#define EN_START_CAP (mEnableCaptureFlow)
#define EN_INIT_REQ_CFG \
  (mInitReqSet > 0)  // Enable InitReq Flow as configure (it might not run since
                     // mInitReqOff)
#define EN_INIT_REQ_RUN \
  (EN_INIT_REQ_CFG && (!mInitReqOff))  // InitReq Flow Enabled and Running
#define EN_REPROCESSING                             \
  (mvStreamImg[STREAM_IMG_IN_OPAQUE] != nullptr) || \
      (mvStreamImg[STREAM_IMG_IN_YUV] != nullptr)

#define IS_BURST_ON (EN_BURST_MODE)
#define IS_BURST_OFF (!EN_BURST_MODE)

#define P1NODE_DEF_SHUTTER_DELAY (2)
#define P1NODE_DEF_PROCESS_DEPTH (3)
#define P1NODE_DEF_QUEUE_DEPTH (8)
#define P1NODE_IMG_BUF_PLANE_CNT_MAX (3)
#define P1NODE_FRAME_NOTE_SLOT_SIZE_DEF (16)
#define P1NODE_FRAME_NOTE_NUM_UNKNOWN ((MINT32)(-1))
#define P1NODE_START_READY_WAIT_CNT_MAX \
  (100)  // * P1NODE_START_READY_WAIT_INV_NS
#define P1NODE_START_READY_WAIT_INV_NS (10000000LL)  // 10ms
#define P1NODE_TRANSFER_JOB_WAIT_CNT_MAX (100)  // * P1NODE_COMMON_WAIT_INV_NS
#define P1NODE_TRANSFER_JOB_WAIT_INV_NS (10000000LL)  // 10ms
#define P1NODE_COMMON_WAIT_CNT_MAX (100)  // * P1NODE_COMMON_WAIT_INV_NS
#define P1NODE_COMMON_MAGICNUM_MASK \
  (0x40000000)  // * P1NODE_COMMON_MAGICNUM_MASK
#define P1NODE_COMMON_WAIT_INV_NS (100000000LL)     // 100ms
#define P1NODE_EVT_DRAIN_WAIT_INV_NS (500000000LL)  // 500ms
#define P1_PERIODIC_INSPECT_INV_NS (3000000000LL)   // 3000ms // 3sec
#define P1_COMMON_CHECK_INV_NS (1000000000LL)       // 1000ms // 1sec
#define P1_QUE_TIMEOUT_CHECK_NS (1000000000LL)      // 1000ms // 1sec
#define P1_DELIVERY_CHECK_INV_NS (2000000000LL)     // 2000ms // 2sec
#define P1_START_CHECK_INV_NS (3000000000LL)        // 3000ms // 3sec
#define P1_CAPTURE_CHECK_INV_NS (4000000000LL)      // 4000ms // 4sec
#define P1_GENERAL_OP_TIMEOUT_US (100000LL)         // 100ms
#define P1_GENERAL_WAIT_OVERTIME_US (500000LL)      // 500ms
#define P1_GENERAL_STUCK_JUDGE_US (800000LL)        // 800ms
#define P1_GENERAL_API_CHECK_US (1000000LL)         // 1000ms // 1sec

#define P1_NOTE_SLEEP(str, ms)                      \
  {                                                 \
    MY_LOGW("[%s] NOTE_SLEEP(%d ms) +++", str, ms); \
    usleep(ms * 1000);                              \
    MY_LOGW("[%s] NOTE_SLEEP(%d ms) ---", str, ms); \
  };

#define ONE_MS_TO_NS (1000000LL)
#define ONE_US_TO_NS (1000LL)
#define ONE_S_TO_US (1000000LL)

/******************************************************************************
 *
 ******************************************************************************/
#define NEED_LOCK(need, mutex) \
  if (need) {                  \
    mutex.lock();              \
  }
#define NEED_UNLOCK(need, mutex) \
  if (need) {                    \
    mutex.unlock();              \
  }

#define P1_FILL_BYTE (0xFF)  // byte

#define CHECK_LAST_FRAME_SKIPPED(LAST_SOF_IDX, THIS_SOF_IDX) \
  ((LAST_SOF_IDX == P1SOFIDX_NULL_VAL)                       \
       ? (true)                                              \
       : ((LAST_SOF_IDX == P1SOFIDX_LAST_VAL)                \
              ? ((THIS_SOF_IDX != 0) ? (true) : (false))     \
              : ((THIS_SOF_IDX != (LAST_SOF_IDX + 1)) ? (true) : (false))));

#define RESIZE_RATIO_MAX_10X (4)
#define RESIZE_RATIO_MAX_100X (25)
#define P1_EISO_MIN_HEIGHT (160)
#define P1_RSSO_MIN_HEIGHT (22)
#define P1_RRZO_MIN_HEIGHT (2)

#define P1_STUFF_BUF_HEIGHT(rrzo, config)                                    \
  ((rrzo)                                                                    \
       ? (MAX(((IS_PORT(CONFIG_PORT_EISO, config)) ? (P1_EISO_MIN_HEIGHT)    \
                                                   : (P1_RRZO_MIN_HEIGHT)),  \
              ((IS_PORT(CONFIG_PORT_RSSO, config)) ? (P1_RSSO_MIN_HEIGHT)    \
                                                   : (P1_RRZO_MIN_HEIGHT)))) \
       : (1))
//
#define P1_IMGO_DEF_FMT (eImgFmt_BAYER10)
#define P1_PRESET_KEY_NULL (0)
#define P1NODE_METADATA_INVALID_VALUE (-1)

#define P1_STRIDE(planes, n) \
  ((planes.size() > n) ? (planes[n].rowStrideInBytes) : (0))

#define IS_RAW_FMT_PACK_FULL(fmt)                   \
  ((((EImageFormat)fmt == eImgFmt_BAYER14_UNPAK) || \
    ((EImageFormat)fmt == eImgFmt_BAYER12_UNPAK) || \
    ((EImageFormat)fmt == eImgFmt_BAYER10_UNPAK) || \
    ((EImageFormat)fmt == eImgFmt_BAYER8_UNPAK))    \
       ? (MFALSE)                                   \
       : (MTRUE))

#define P1NODE_RES_CON_ACQUIRE(Ctrl, Client, Got)                       \
  {                                                                     \
    P1NODE_RES_CON_RETURN(Ctrl, Client);                                \
    if (Got == MFALSE) {                                                \
      Client = Ctrl->requestClient();                                   \
      if (Client != IResourceConcurrency::CLIENT_HANDLER_NULL) {        \
        MY_LOGI("[ResCon][%p-%d] resource acquiring", Ctrl.get(),       \
                (MUINT32)Client);                                       \
        CAM_TRACE_FMT_BEGIN("P1:Res-Acquire[%p-%d]", Ctrl.get(),        \
                            (MUINT32)Client);                           \
        MERROR res = Ctrl->acquireResource(Client);                     \
        CAM_TRACE_FMT_END();                                            \
        if (res == NO_ERROR) {                                          \
          MY_LOGI("[ResCon][%p-%d] resource acquired (%d)", Ctrl.get(), \
                  (MUINT32)Client, res);                                \
          Got = MTRUE;                                                  \
        } else {                                                        \
          MY_LOGI("[ResCon][%p-%d] cannot acquire (%d)", Ctrl.get(),    \
                  (MUINT32)Client, res);                                \
          Got = MFALSE;                                                 \
          P1NODE_RES_CON_RETURN(Ctrl, Client);                          \
        }                                                               \
      } else {                                                          \
        MY_LOGI("[ResCon][%p-%d] cannot request", Ctrl.get(),           \
                (MUINT32)Client);                                       \
        Got = MFALSE;                                                   \
      }                                                                 \
    }                                                                   \
  }

#define P1NODE_RES_CON_RELEASE(Ctrl, Client, Got)                       \
  {                                                                     \
    if (Got == MTRUE) {                                                 \
      if (Client != IResourceConcurrency::CLIENT_HANDLER_NULL) {        \
        MY_LOGI("[ResCon][%p-%d] resource releasing", Ctrl.get(),       \
                (MUINT32)Client);                                       \
        CAM_TRACE_FMT_BEGIN("P1:Res-Release[%p-%d]", Ctrl.get(),        \
                            (MUINT32)Client);                           \
        MERROR res = Ctrl->releaseResource(Client);                     \
        CAM_TRACE_FMT_END();                                            \
        if (res == NO_ERROR) {                                          \
          MY_LOGI("[ResCon][%p-%d] resource released (%d)", Ctrl.get(), \
                  (MUINT32)Client, res);                                \
        } else {                                                        \
          MY_LOGI("[ResCon][%p-%d] cannot release (%d)", Ctrl.get(),    \
                  (MUINT32)Client, res);                                \
        }                                                               \
      }                                                                 \
      Got = MFALSE;                                                     \
    }                                                                   \
    P1NODE_RES_CON_RETURN(Ctrl, Client);                                \
  }

#define P1NODE_RES_CON_RETURN(Ctrl, Client)                         \
  {                                                                 \
    if (Client != IResourceConcurrency::CLIENT_HANDLER_NULL) {      \
      MERROR res = Ctrl->returnClient(Client);                      \
      if (res == NO_ERROR) {                                        \
        MY_LOGI("[ResCon][%p-%d] client returned (%d)", Ctrl.get(), \
                (MUINT32)Client, res);                              \
      } else {                                                      \
        MY_LOGI("[ResCon][%p-%d] cannot return (%d)", Ctrl.get(),   \
                (MUINT32)Client, res);                              \
      }                                                             \
      Client = IResourceConcurrency::CLIENT_HANDLER_NULL;           \
    }                                                               \
  }

#define P1_LOG_META(act, meta, info)                              \
  if (mMetaLogOp > 0) {                                           \
    std::string str("[P1Meta]");                                  \
    str += base::StringPrintf("[%s]", info);                      \
    str += base::StringPrintf("[Cam::%d]", getOpenId());          \
    str += base::StringPrintf(P1NUM_ACT_STR, P1NUM_ACT_VAR(act)); \
    logMeta(mMetaLogOp, meta, str.c_str(), mMetaLogTag);          \
  }
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

/******************************************************************************
 *
 ******************************************************************************/
typedef NS3Av3::IHal3A IHal3A_T;

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

/******************************************************************************
 *
 ******************************************************************************/

enum START_STATE {
  START_STATE_NULL = 0,
  START_STATE_DRV_START,
  START_STATE_CAP_MANUAL_ENQ,
  START_STATE_LMV_SENSOR_EN,
  START_STATE_READY
};

enum EXE_STATE {
  EXE_STATE_NULL = 0,
  EXE_STATE_REQUESTED,
  EXE_STATE_PROCESSING,
  EXE_STATE_DONE
};
//
#if 1  // SUPPORT_UNI_SWITCH
enum UNI_SWITCH_STATE {
  UNI_SWITCH_STATE_NONE = 0,  // no UNI switch-out request
  UNI_SWITCH_STATE_REQ,  // received the switch-out request, need to switch-out
  UNI_SWITCH_STATE_ACT_ACCEPT,  // UNI is held and it will switch-out
  UNI_SWITCH_STATE_ACT_IGNORE,  // UNI is not held, ignore this switch-out
  UNI_SWITCH_STATE_ACT_REJECT   // UNI is switching and reject this switch-out
};
#endif
//
#if 1  // SUPPORT_TG_SWITCH
enum TG_SWITCH_STATE {
  TG_SWITCH_STATE_NONE = 0,     // no TG switch request
  TG_SWITCH_STATE_REQ,          // received the TG switch request
  TG_SWITCH_STATE_DONE_ACCEPT,  // TG switch command done and it accept
  TG_SWITCH_STATE_DONE_IGNORE,  // TG switch command done and it ignore
  TG_SWITCH_STATE_DONE_REJECT   // TG switch command done and it reject
};
#endif
//
#if 1  // SUPPORT_QUALITY_SWITCH
#define QUALITY_SWITCH_STATE_REQ_NON 0x80
#define QUALITY_SWITCH_STATE_REQ_H_A 0x40
#define QUALITY_SWITCH_STATE_REQ_H_B 0x20
enum QUALITY_SWITCH_STATE {
  QUALITY_SWITCH_STATE_NONE = 0,      // no QUALITY switch request
  QUALITY_SWITCH_STATE_DONE_ACCEPT,   // QUALITY switch command done and it
                                      // accept
  QUALITY_SWITCH_STATE_DONE_IGNORE,   // QUALITY switch command done and it
                                      // ignore
  QUALITY_SWITCH_STATE_DONE_REJECT,   // QUALITY switch command done and it
                                      // reject
  QUALITY_SWITCH_STATE_DONE_ILLEGAL,  // QUALITY switch command not accepted
                                      // since switching

  // received the QUALITY switch request
  QUALITY_SWITCH_STATE_REQ_L_L  // 0x80
  = (QUALITY_SWITCH_STATE_REQ_NON),
  QUALITY_SWITCH_STATE_REQ_L_H  // 0xA0 = 0x80 | 0x20
  = (QUALITY_SWITCH_STATE_REQ_NON | QUALITY_SWITCH_STATE_REQ_H_B),
  QUALITY_SWITCH_STATE_REQ_H_L  // 0xC0 = 0x80 | 0x40
  = (QUALITY_SWITCH_STATE_REQ_NON | QUALITY_SWITCH_STATE_REQ_H_A),
  QUALITY_SWITCH_STATE_REQ_H_H  // 0xE0 = 0x80 | 0x40 | 0x20
  = (QUALITY_SWITCH_STATE_REQ_NON | QUALITY_SWITCH_STATE_REQ_H_A |
     QUALITY_SWITCH_STATE_REQ_H_B)
};
#endif
//
#if 1  // SUPPORT_SENSOR_STATUS_CONTROL // for standby mode
enum SENSOR_STATUS_CTRL {
  SENSOR_STATUS_CTRL_NONE = 0,  // no sensor status control request
  SENSOR_STATUS_CTRL_STANDBY,   // received the STANDBY request
  SENSOR_STATUS_CTRL_STREAMING  // received the STREAMING request
};
#endif
//
enum REQ_REV_RES {  // Request Receive Result
  REQ_REV_RES_UNKNOWN = 0,
  REQ_REV_RES_ACCEPT_AVAILABLE,
  REQ_REV_RES_ACCEPT_BYPASS,
  REQ_REV_RES_REJECT_NOT_AVAILABLE,
  REQ_REV_RES_REJECT_NO_IO_MAP_SET,
  REQ_REV_RES_REJECT_IO_PIPE_EVT,
  REQ_REV_RES_MAX
};
//
enum ACT_TYPE {
  ACT_TYPE_NULL = 0,
  ACT_TYPE_NORMAL,
  ACT_TYPE_INTERNAL,
  ACT_TYPE_BYPASS
};
//
enum REQ_TYPE {
  REQ_TYPE_UNKNOWN = 0,
  REQ_TYPE_NORMAL,
  REQ_TYPE_INITIAL,
  REQ_TYPE_DUMMY,
  REQ_TYPE_PADDING,
  REQ_TYPE_REDO,
  REQ_TYPE_YUV,
  REQ_TYPE_ZSL
};
//
#define REQ_SET(bit) ((MUINT32)(0x1 << bit))
#define REQ_SET_NONE (0x0)
#define IS_OUT(out, set) ((set & REQ_SET(out)) == REQ_SET(out))
enum REQ_OUT {
  // @ bit
  REQ_OUT_RESIZER = 0,    // 0x 01
  REQ_OUT_RESIZER_STUFF,  // 1     // 0x 02
  REQ_OUT_LCSO,           // 2     // 0x 04
  REQ_OUT_LCSO_STUFF,     // 3     // 0x 08
  REQ_OUT_FULL_PURE,      // 4     // 0x 10
  REQ_OUT_FULL_PROC,      // 5     // 0x 20
  REQ_OUT_FULL_OPAQUE,    // 6     // 0x 40
  REQ_OUT_FULL_STUFF,     // 7     // 0x 80
  REQ_OUT_RSSO,           // 8     // 0x 0100
  REQ_OUT_RSSO_STUFF,     // 9     // 0x 0200
  REQ_OUT_MAX
};
//
#define EXP_REC(bit) ((MUINT32)(0x1 << bit))
#define EXP_REC_NONE (0x0)
#define IS_EXP(exp, rec) ((rec & EXP_REC(exp)) == EXP_REC(exp))
enum EXP_EVT {
  EXP_EVT_UNKNOWN = 0,
  EXP_EVT_NOBUF_RRZO,
  EXP_EVT_NOBUF_IMGO,
  EXP_EVT_NOBUF_EISO,
  EXP_EVT_NOBUF_LCSO,
  EXP_EVT_NOBUF_RSSO,
  EXP_EVT_MAX
};
//
#define P1_PORT_BUF_IDX_NONE \
  (0xFFFFFFFF)  // MUINT32 (4 bytes with P1_FILL_BYTE)
#define P1_META_GENERAL_EMPTY_INT ((MINT32)(-1))
//
enum P1_OUTPUT_PORT {
  P1_OUTPUT_PORT_RRZO = 0,
  P1_OUTPUT_PORT_IMGO,  // 1
  P1_OUTPUT_PORT_EISO,  // 2
  P1_OUTPUT_PORT_LCSO,  // 3
  P1_OUTPUT_PORT_RSSO,  // 4
  P1_OUTPUT_PORT_TOTAL  // (max:32) for CONFIG_PORT (MUINT32)
};
//
#define IS_PORT(port, set) ((set & port) == port)
enum CONFIG_PORT {
  CONFIG_PORT_NONE = (0x0),
  CONFIG_PORT_RRZO = (0x1 << P1_OUTPUT_PORT_RRZO),  // 0x01
  CONFIG_PORT_IMGO = (0x1 << P1_OUTPUT_PORT_IMGO),  // 0x02
  CONFIG_PORT_EISO = (0x1 << P1_OUTPUT_PORT_EISO),  // 0x04
  CONFIG_PORT_LCSO = (0x1 << P1_OUTPUT_PORT_LCSO),  // 0x08
  CONFIG_PORT_RSSO = (0x1 << P1_OUTPUT_PORT_RSSO),  // 0x10
  CONFIG_PORT_ALL = (0xFFFFFFFF)                    // MUINT32
};
//
enum ENQ_TYPE { ENQ_TYPE_NORMAL = 0, ENQ_TYPE_INITIAL, ENQ_TYPE_DIRECTLY };
//
enum P1_FLUSH_REASON {
  P1_FLUSH_REASON_GENERAL = 0,
  P1_FLUSH_REASON_PROCEDURE_FAIL,      // 1
  P1_FLUSH_REASON_OPERATION_INACTIVE,  // 2
  P1_FLUSH_REASON_NOTIFICATION_DROP,   // 3
  P1_FLUSH_REASON_INTERNAL_INITIAL,    // 4
  P1_FLUSH_REASON_INTERNAL_PADDING,    // 5
  P1_FLUSH_REASON_INTERNAL_DUMMY,      // 6
  P1_FLUSH_REASON_BYPASS_ABANDON,      // 7
  P1_FLUSH_REASON_TERMINAL_COLLECTOR,  // 8
  P1_FLUSH_REASON_TERMINAL_REQUESTQ,   // 9
  P1_FLUSH_REASON_TERMINAL_PROCESSQ,   // 10
  P1_FLUSH_REASON_REQUEST_KICK,        // 11
  P1_FLUSH_REASON_MISMATCH_EXP,        // 12
  P1_FLUSH_REASON_MISMATCH_UNCERTAIN,  // 13
  P1_FLUSH_REASON_MISMATCH_BUFFER,     // 14
  P1_FLUSH_REASON_MISMATCH_RAW,        // 15
  P1_FLUSH_REASON_MISMATCH_RESULT,     // 16
  P1_FLUSH_REASON_MISMATCH_RESIZE,     // 17
  P1_FLUSH_REASON_MISMATCH_READOUT,    // 18
  P1_FLUSH_REASON_MISMATCH_SYNC,       // 18
  P1_FLUSH_REASON_TOTAL                // (max:32) for FLUSH_TYPE (MUINT32)
};
#define IS_FLUSH(type, set) ((set & type) > 0)  // return true as one type match
enum FLUSH_TYPE {
  FLUSH_NONEED = (0x0),
  FLUSH_GENERAL = (0x1 << P1_FLUSH_REASON_GENERAL),              // 0x1
  FLUSH_FAIL = (0x1 << P1_FLUSH_REASON_PROCEDURE_FAIL),          // 0x2
  FLUSH_INACTIVE = (0x1 << P1_FLUSH_REASON_OPERATION_INACTIVE),  // 0x4
  FLUSH_DROP = (0x1 << P1_FLUSH_REASON_NOTIFICATION_DROP),       // 0x8
  FLUSH_INITIAL = (0x1 << P1_FLUSH_REASON_INTERNAL_INITIAL),     // 0x10
  FLUSH_PADDING = (0x1 << P1_FLUSH_REASON_INTERNAL_PADDING),     // 0x20
  FLUSH_DUMMY = (0x1 << P1_FLUSH_REASON_INTERNAL_DUMMY),         // 0x40
  FLUSH_INTERNAL =
      (FLUSH_INITIAL | FLUSH_PADDING | FLUSH_DUMMY),  // 0x10|0x20|0x40 = 0x70
  FLUSH_ABANDON = (0x1 << P1_FLUSH_REASON_BYPASS_ABANDON),        // 0x80
  FLUSH_COLLECTOR = (0x1 << P1_FLUSH_REASON_TERMINAL_COLLECTOR),  // 0x100
  FLUSH_REQUESTQ = (0x1 << P1_FLUSH_REASON_TERMINAL_REQUESTQ),    // 0x200
  FLUSH_PROCESSQ = (0x1 << P1_FLUSH_REASON_TERMINAL_PROCESSQ),    // 0x400
  FLUSH_TERMINAL = (FLUSH_COLLECTOR | FLUSH_REQUESTQ |
                    FLUSH_PROCESSQ),  // 0x100|0x200|0x400 = 0x700
  FLUSH_KICK = (0x1 << P1_FLUSH_REASON_REQUEST_KICK),                 // 0x800
  FLUSH_MIS_EXP = (0x1 << P1_FLUSH_REASON_MISMATCH_EXP),              // 0x1000
  FLUSH_MIS_UNCERTAIN = (0x1 << P1_FLUSH_REASON_MISMATCH_UNCERTAIN),  // 0x2000
  FLUSH_MIS_BUFFER = (0x1 << P1_FLUSH_REASON_MISMATCH_BUFFER),        // 0x4000
  FLUSH_MIS_RAW = (0x1 << P1_FLUSH_REASON_MISMATCH_RAW),              // 0x8000
  FLUSH_MIS_RESULT = (0x1 << P1_FLUSH_REASON_MISMATCH_RESULT),        // 0x10000
  FLUSH_MIS_RESIZE = (0x1 << P1_FLUSH_REASON_MISMATCH_RESIZE),        // 0x20000
  FLUSH_MIS_READOUT = (0x1 << P1_FLUSH_REASON_MISMATCH_READOUT),      // 0x40000
  FLUSH_MIS_SYNC = (0x1 << P1_FLUSH_REASON_MISMATCH_SYNC),            // 0x80000
  FLUSH_ALL = (0xFFFFFFFF)                                            // MUINT32
};
//
enum PREPARE_CROP_PHASE {
  PREPARE_CROP_PHASE_RECEIVE_CREATE,
  PREPARE_CROP_PHASE_CONTROL_RESIZE,
};
//
enum INFLIGHT_MONITORING_TIMING {
  IMT_COMMON = 0,
  IMT_REQ,
  IMT_ENQ,
  IMT_DEQ,
  IMT_MAX
};
//
#define BIN_RESIZE(x) (x = (x >> 1))
#define BIN_REVERT(x) (x = (x << 1))

//
#define STREAM_ITEM_START (0)
//
enum STREAM_IMG {
  STREAM_IMG_IN_YUV = STREAM_ITEM_START,
  STREAM_IMG_IN_OPAQUE,
  STREAM_IMG_OUT_OPAQUE,
  STREAM_IMG_OUT_FULL,
  STREAM_IMG_OUT_RESIZE,
  STREAM_IMG_OUT_LCS,
  STREAM_IMG_OUT_RSS,
  STREAM_IMG_NUM
};
#define STREAM_IMG_IN_BGN STREAM_IMG_IN_YUV
#define STREAM_IMG_IN_END STREAM_IMG_IN_OPAQUE
#define IS_IN_STREAM_IMG(img) \
  ((img == STREAM_IMG_IN_YUV) || (img == STREAM_IMG_IN_OPAQUE))
//
enum STREAM_META {
  STREAM_META_IN_APP = STREAM_ITEM_START,
  STREAM_META_IN_HAL,
  STREAM_META_OUT_APP,
  STREAM_META_OUT_HAL,
  STREAM_META_NUM
};
#define IS_IN_STREAM_META(meta) \
  ((meta == STREAM_META_IN_APP) || (meta == STREAM_META_IN_HAL))

//
enum IMG_BUF_SRC {
  IMG_BUF_SRC_NULL = 0,
  IMG_BUF_SRC_POOL,
  IMG_BUF_SRC_STUFF,
  IMG_BUF_SRC_FRAME
};

enum SLG {                     // Sys-Level-Group
  SLG_OFF = P1_SYS_LV_OFF,     // forced-off
  SLG_B = P1_SYS_LV_BASIC,     // basic basis base
  SLG_E = P1_SYS_LV_BASIC,     // event or exception
  SLG_S = P1_SYS_LV_CRITICAL,  // start/stop significance
  SLG_R = P1_SYS_LV_DEFAULT,   // start/stop reference
  SLG_I = P1_SYS_LV_DEFAULT,   // inflight information
  SLG_O = P1_SYS_LV_VERBOSE,   // others
  SLG_PFL = P1_SYS_LV_BASIC    // per-frame-log // it should not present in
                               // performance checking by log level control
};

};  // namespace NSP1Node
};  // namespace v3
};  // namespace NSCam

#endif  // CAMERA_HAL_MEDIATEK_MTKCAM_PIPELINE_HWNODE_P1_P1COMMON_H_