拍照时闪光灯调用HAL层到driver层流程

平台	MT6739
版本	Android 9.0

HAL层

HAL层闪光灯调用具体函数执行流程

Hal3AIf::getInstance的实现

打开相机APK时调用的初始化函数

./vendor/mediatek/proprietary/hardware/mtkcam/aaa/source/common/hal3a/v1.0/aaa_hal_if.cpp

Hal3AIf::getInstance(MINT32 const i4SensorOpenIndex, E_FlowControl_Type eType, MINT32 i4SubsampleCount)
{
   
    CAM_LOGD("[%s] sensoridx(%d)", __FUNCTION__, i4SensorOpenIndex);
    switch (eType)
    {
   
    case Hal3AIf::E_FlowControl_Type_SMVR:
        return Hal3AFlowCtrl_SMVR::getInstance(i4SensorOpenIndex, i4SubsampleCount);
    case Hal3AIf::E_FlowControl_Type_NORMAL:
        return Hal3AFlowCtrl::getInstance(i4SensorOpenIndex);
    default:
        return NULL;
    }
}

Hal3AFlowCtrl::getInstance的实现

./vendor/mediatek/proprietary/hardware/mtkcam/aaa/source/common/hal3a/v1.0/Hal3AFlowCtrl.cpp

Hal3AIf*
Hal3AFlowCtrl::
getInstance(MINT32 i4SensorOpenIndex)
{
   
    IHalSensorList* const pHalSensorList = MAKE_HalSensorList();
    if (!pHalSensorList) return NULL;

    MINT32 i4SensorDev = pHalSensorList->querySensorDevIdx(i4SensorOpenIndex);

    switch (i4SensorDev)
    {
   
        case SENSOR_DEV_MAIN:
        {
   
            static Hal3AFlowCtrl _singleton(SENSOR_DEV_MAIN);
            _singleton.init(i4SensorOpenIndex);
            return &_singleton;
        }
        case SENSOR_DEV_SUB:
        {
   
            static Hal3AFlowCtrl _singleton(SENSOR_DEV_SUB);
            _singleton.init(i4SensorOpenIndex);
            return &_singleton;
        }
        case SENSOR_DEV_MAIN_2:
        {
   
            static Hal3AFlowCtrl _singleton(SENSOR_DEV_MAIN_2);
            _singleton.init(i4SensorOpenIndex);
            return &_singleton;
        }
        case SENSOR_DEV_SUB_2:
        {
   
            static Hal3AFlowCtrl _singleton(SENSOR_DEV_SUB_2);
            _singleton.init(i4SensorOpenIndex);
            return &_singleton;
        }
        case SENSOR_DEV_MAIN_3:
        {
   
            static Hal3AFlowCtrl _singleton(SENSOR_DEV_MAIN_3);
            _singleton.init(i4SensorOpenIndex);
            return &_singleton;
        }
    default:
        CAM_LOGE("Unsupport sensor device ID: %d\n", i4SensorDev);
        AEE_ASSERT_3A_HAL("Unsupport sensor device.");
        return MNULL;
    }
}

Hal3AFlowCtrl::init的实现

./vendor/mediatek/proprietary/hardware/mtkcam/aaa/source/common/hal3a/v1.0/Hal3AFlowCtrl.cpp

MRESULT
Hal3AFlowCtrl::
init(MINT32 i4SensorOpenIndex) //can be called only once by RAW or YUV, no user count
{
   
    MY_LOGD("[%s] +", __FUNCTION__);

    m_fgLogEn = ::property_get_int32("vendor.debug.camera.log", 0);
    if ( m_fgLogEn == 0 ) {
   
        m_fgLogEn = ::property_get_int32("vendor.debug.camera.log.hal3a", 0);
    }
    m_u4FrmIdFreeze = ::property_get_int32("vendor.debug.3a.freeze", 0);
    m_bRRZDump = 0;
    m_fgDebugLogWEn = DebugUtil::getDebugLevel(DBG_3A);

    IHalSensorList*const pHalSensorList = MAKE_HalSensorList();
    if (!pHalSensorList) return 0;

#if (CAM3_3ATESTLVL <= CAM3_3AUT)
    I3AWrapper::E_TYPE_T eType = I3AWrapper::E_TYPE_DFT;
#else
    MINT32 eSensorType = pHalSensorList->queryType(i4SensorOpenIndex);
    I3AWrapper::E_TYPE_T eType = I3AWrapper::E_TYPE_RAW;
    switch (eSensorType)
    {
   
    case NSSensorType::eRAW:
        eType = I3AWrapper::E_TYPE_RAW;
        break;
    case NSSensorType::eYUV:
        eType = I3AWrapper::E_TYPE_YUV;
        break;
    default:
        eType = I3AWrapper::E_TYPE_DFT;
        break;
    }
#endif

    m_i4SensorOpenIdx = i4SensorOpenIndex;

    // create 3A wrapper
    if (m_p3AWrap == NULL)
    {
   
        m_p3AWrap = I3AWrapper::getInstance(eType, i4SensorOpenIndex);
        if (m_p3AWrap)
        {
   
            MY_LOGD_IF(m_fgLogEn, "[%s] m_p3AWrapper(%p) created OK", __FUNCTION__, m_p3AWrap);
        }
        else
        {
   
            CAM_LOGE("m_p3AWrapper created fail!");
            AEE_ASSERT_3A_HAL("m_p3AWrapper created fail!");
        }
    }

    // create Vsync event
    //IEventIrq::ConfigParam IrqConfig(i4SensorDev, i4SensorOpenIndex, 5000, IEventIrq::E_Event_Vsync);
    //m_pEventIrq = IEventIrq::createInstance(IrqConfig, "VSIrq");

    m_SttBufQEnable = property_get_int32("vendor.debug.camera.SttBufQ.enable", 0);
    if (m_SttBufQEnable) {
   
        ISttBufQ::createSingleton(m_i4SensorDev, LOG_TAG);
    }

    // create statistic control
#if (CAM3_3ATESTLVL >= CAM3_3ASTTUT)
    if (m_p3ASttCtrl == NULL  && eType == I3AWrapper::E_TYPE_RAW)
    {
   
        m_p3ASttCtrl = Hal3ASttCtrl::createInstance(m_i4SensorDev, i4SensorOpenIndex);
        if (m_p3ASttCtrl)
        {
   
            MY_LOGD_IF(m_fgLogEn, "[%s] m_p3ASttCtrl(%p) created OK", __FUNCTION__, m_p3ASttCtrl);
        }
        else
        {
   
            CAM_LOGE("m_p3ASttCtrl created fail!");
            AEE_ASSERT_3A_HAL("m_p3ASttCtrl created fail!");
        }
    }
#endif

    // create AA thread
    if (m_pThread == NULL)
    {
   
    	/* 闪光灯的相关操作在这个线程中实现 */
        m_pThread = IThread3A::createInstance(this);
        if (m_pThread)
        {
   
            MY_LOGD_IF(m_fgLogEn, "[%s] m_pThread(%p) created OK", __FUNCTION__, m_pThread);
        }
        else
        {
   
            CAM_LOGE("m_pThread created fail!");
            AEE_ASSERT_3A_HAL("m_pThread created fail!");
        }
    }

    // ResultPool - Get result pool object
    if(m_pResultPoolObj == NULL)
        m_pResultPoolObj = IResultPool::getInstance(m_i4SensorDev);
    if(m_pResultPoolObj == NULL)
        CAM_LOGE("ResultPool getInstance fail");

    MY_LOGD("[%s] - eType(%d), sensor(%d), sensorIdx(%d)", __FUNCTION__, eType, m_i4SensorDev, i4SensorOpenIndex);
    return S_3A_OK;
}

IThread3A::createInstance的实现

./vendor/mediatek/proprietary/hardware/mtkcam/aaa/source/common/hal3a/v1.0/Thread3AImp.cpp

IThread3A*
IThread3A::createInstance(Hal3AIf* pHal3A)
{
   
    return Thread3AImp::createInstance(pHal3A);
}

Thread3AImp::createInstance的实现

./vendor/mediatek/proprietary/hardware/mtkcam/aaa/source/common/hal3a/v1.0/Thread3AImp.cpp

IThread3A*
Thread3AImp::
createInstance(Hal3AIf* pHal3A)
{
   
    //static Thread3AImp singleton(pHal3A);
    //singleton.createThread();   // user count protected
    //return &singleton;
    Thread3AImp* pThd3A = new Thread3AImp(pHal3A);
    //if (pThd3A)
        //pThd3A->createThread();
    return pThd3A;
}

Thread3AImp::Thread3AImp的实现

./vendor/mediatek/proprietary/hardware/mtkcam/aaa/source/common/hal3a/v1.0/Thread3AImp.cpp

Thread3AImp::
Thread3AImp(Hal3AIf* pHal3A)
    : mpHal3A(pHal3A)
    , mu4LogEn(MFALSE)
    , mbListenUpdate(MFALSE)
    , mbSetFromP1(MFALSE)
    , mLock()
{
   
    MY_LOGD("[%s] Enter (%d)", __FUNCTION__, pHal3A->getSensorDev());
    createThread();
}

Thread3AImp::createThread的实现

./vendor/mediatek/proprietary/hardware/mtkcam/aaa/source/common/hal3a/v1.0/Thread3AImp.cpp

MVOID
Thread3AImp::createThread()
{
   
    //Mutex::Autolock lock(mLock);  // Nelson : mutual exclusive by atomic_flag

    GET_PROP("vendor.debug.3a.log", 0, mu4LogEn);
    mu4DebugLogWEn = DebugUtil::getDebugLevel(DBG_3A);

    if (!thread_alive.test_and_set())
    {
   
        MY_LOGD("[%s] +", __FUNCTION__);
        sem_init(&mSem, 0, 0);
        //pthread_create(&mThread, NULL, onThreadLoop, this);
        create3Athread = thread(onThreadLoop, this);
        MY_LOGD("[%s] -", __FUNCTION__);
    }
}

在打开相机APK后，会通过 Thread3AImp::createThread() 函数创建并执行了线程 create3Athread ，它最终会调用 Thread3AImp::onThreadLoop() 方法

Thread3AImp::onThreadLoop的实现

./vendor/mediatek/proprietary/hardware/mtkcam/aaa/source/common/hal3a/v1.0/Thread3AImp.cpp

MVOID*
Thread3AImp::onThreadLoop(MVOID *arg)
{
   
    MY_LOGD("+");

    CmdQ_T rCmd(ECmd_Update, ParamIspProfile_T());
    Thread3AImp *_this = reinterpret_cast<Thread3AImp*>(arg);
//    AaaTimer ccTimer;
    MBOOL bGetCmd;
    MBOOL fgLogEn = (_this->mu4LogEn & EN_LOG_3A_THREAD) ? MTRUE : MFALSE;
    MUINT32 cmdQSize = 0;

    // (1) change thread setting
    _this->changeThreadSetting();

    // (2) thread-in-loop
    while (_this->getCommand(rCmd, bGetCmd, MFALSE)) /* 从 getCommand() 中获取rCmd的值 */
    {
   
        //MY_LOGD_IF(1, "rCmd(%d)+", rCmd);
        //
        DebugUtil::getInstance(_this->mpHal3A->getSensorDev())->update(LOG_TAG, "onThreadLoop", 0);
        switch (rCmd.eCmd)
        {
   
            case ECmd_Update:
                if (!_this->mbListenUpdate)
                {
   
                    MY_LOGD("[%s] Exit 3A thread", __FUNCTION__);
                    break;
                }
                MY_LOGD_IF(fgLogEn, "rCmd(%d)+", rCmd.eCmd);
                DebugUtil::getInstance(_this->mpHal3A->getSensorDev())->update(LOG_TAG, "onThreadLoop", 1);

                /* 在这函数里不断通过 post_commnad 发送 ECmd_Update 命令 */
                if (!_this->mpHal3A->doUpdateCmd(&rCmd.rParamIspProfile))//on3aprocfinish
                {
   
                    char strErr[512] = {
   '\0'};
                    sprintf(strErr, "ECmd_Update failed #(%d)", rCmd.rParamIspProfile.i4MagicNum);
                    CAM_LOGE("%s", strErr);
                    AEE_ASSERT_3A_HAL(strErr);
                }

                if (!_this->mbSetFromP1) //only check before first set from MW
                {
   
                    if (rCmd.rParamIspProfile.iValidateOpt != ParamIspProfile_T::EParamValidate_None)
                    {
   
                        MY_LOGD("[%s] First command from P1",__FUNCTION__);
                        _this->mbSetFromP1 = MTRUE;
                    }
                }
                DebugUtil::getInstance(_this->mpHal3A->getSensorDev())->update(LOG_TAG, "onThreadLoop", 2);

                _this->mpHal3A->on3AProcSet(_this->mbSetFromP1);//vsync callback

                DebugUtil::getInstance(_this->mpHal3A->getSensorDev())->update(LOG_TAG, "onThreadLoop", 3);
                {
   
                    Mutex::Autolock autoLock(_this->mModuleMtx);
                    cmdQSize = _this->mCmdQ.size();
                }
                if (cmdQSize)
                {
   
                    MY_LOGD_IF(fgLogEn, "[%s] Cmd from P1", __FUNCTION__);
                }
                else
                {
   
                    if (_this->mbSetFromP1)
                    {
   
                        _this->mpHal3A->doUpdateCmdDummy();
                        MY_LOGD_IF(fgLogEn, "[%s] Dummy cmd from 3A Thread", __FUNCTION__);
                    }
                }

                MY_LOGD_IF(fgLogEn, "rCmd(%d), magic#(%d)-", rCmd.eCmd, rCmd.rParamIspProfile.i4MagicNum);
            break;

            default:
                AAA_TRACE_HAL(Thread3A_CmdDefault);
                MY_LOGD_IF(fgLogEn, "rCmd(%d)+", rCmd.eCmd);
                //
                DebugUtil::getInstance(_this->mpHal3A->getSensorDev())->update(LOG_TAG, "onThreadLoop", 4);
                if ( ! _this->mpHal3A->postCommand(rCmd.eCmd, &rCmd.rParamIspProfile))
                {
   
                    CAM_LOGE("Cmd(%d) failed", rCmd.eCmd);
                    AEE_ASSERT_3A_HAL("onThreadLoop postCommand fail(2).");
                }
                //
                if (rCmd.eCmd != ECmd_PrecaptureStart && rCmd.eCmd != ECmd_PrecaptureEnd)
                {
   
                    ::sem_post(&_this->mSem);
                }
                MY_LOGD_IF(fgLogEn, "rCmd(%d), magic#(%d)-", rCmd.eCmd, rCmd.rParamIspProfile.i4MagicNum);
                AAA_TRACE_END_HAL;
            break;
        <