Android Camera CameraHal.cpp 初始化分析

最新推荐文章于 2024-04-09 10:08:32 发布
最新推荐文章于 2024-04-09 10:08:32 发布
阅读量831 收藏
点赞数
Android Camera CameraHal.cpp 分析

作为上层和底层的中转站，hal层在android中起到的作用不言而喻，针对camera的研究已经有一段时间了，这里自己还是决定静下心来好好的分析一下CameraHal.cpp这里的代码，
对自己更好的理解hal与上层和底层的交互作用不可小觑，特别对理解hal与kernel driver的交互过程作用很大
不多说废话了，开始今天的主题

我们首先从CameraHal的初始化，那么他是从哪里开始化的呢？这里之前的文章中已经有过，只是没有重点介绍，这里还是说一下吧
是在camera最初open的时候会调用到camerahal_module.cpp中的以下方法进行初始化的
  1. /*******************************************************************
  2.  * implementation of camera_module functions
  3.  *******************************************************************/

  5. /* open device handle to one of the cameras
  6.  *
  7.  * assume camera service will keep singleton of each camera
  8.  * so this function will always only be called once per camera instance
  9.  */

  11. int camera_device_open(const hw_module_t* module, const char* name,
  12.                 hw_device_t** device)
  13. {
  14.     int rv = 0;
  15.     int num_cameras = 0;
  16.     int cameraid;
  17.     ti_camera_device_t* camera_device = NULL;
  18.     camera_device_ops_t* camera_ops = NULL;
  19.     android::CameraHal* camera = NULL;
  20.     android::CameraProperties::Properties* properties = NULL;

  22.     android::Mutex::Autolock lock(gCameraHalDeviceLock);

  24.     LOGI("camera_device open");

  26.     if (name != NULL) {
  27.         cameraid = atoi(name);
  28.         num_cameras = gCameraProperties.camerasSupported();

  30.         if(cameraid > num_cameras)
  31.         {
  32.             LOGE("camera service provided cameraid out of bounds, "
  33.                     "cameraid = %d, num supported = %d",
  34.                     cameraid, num_cameras);
  35.             rv = -EINVAL;
  36.             goto fail;
  37.         }

  39.         if(gCamerasOpen >= MAX_SIMUL_CAMERAS_SUPPORTED)
  40.         {
  41.             LOGE("maximum number of cameras already open");
  42.             rv = -ENOMEM;
  43.             goto fail;
  44.         }

  46.         camera_device = (ti_camera_device_t*)malloc(sizeof(*camera_device));
  47.         if(!camera_device)
  48.         {
  49.             LOGE("camera_device allocation fail");
  50.             rv = -ENOMEM;
  51.             goto fail;
  52.         }

  54.         camera_ops = (camera_device_ops_t*)malloc(sizeof(*camera_ops));
  55.         if(!camera_ops)
  56.         {
  57.             LOGE("camera_ops allocation fail");
  58.             rv = -ENOMEM;
  59.             goto fail;
  60.         }

  62.         memset(camera_device, 0, sizeof(*camera_device));
  63.         memset(camera_ops, 0, sizeof(*camera_ops));

  65.         camera_device->base.common.tag = HARDWARE_DEVICE_TAG;
  66.         camera_device->base.common.version = 0;
  67.         camera_device->base.common.module = (hw_module_t *)(module);
  68.         camera_device->base.common.close = camera_device_close;
  69.         camera_device->base.ops = camera_ops;

  71.         camera_ops->set_preview_window = camera_set_preview_window;
  72.         camera_ops->set_callbacks = camera_set_callbacks;
  73.         camera_ops->enable_msg_type = camera_enable_msg_type;
  74.         camera_ops->disable_msg_type = camera_disable_msg_type;
  75.         camera_ops->msg_type_enabled = camera_msg_type_enabled;
  76.         camera_ops->start_preview = camera_start_preview;
  77.         camera_ops->stop_preview = camera_stop_preview;
  78.         camera_ops->preview_enabled = camera_preview_enabled;
  79.         camera_ops->store_meta_data_in_buffers = camera_store_meta_data_in_buffers;
  80.         camera_ops->start_recording = camera_start_recording;
  81.         camera_ops->stop_recording = camera_stop_recording;
  82.         camera_ops->recording_enabled = camera_recording_enabled;
  83.         camera_ops->release_recording_frame = camera_release_recording_frame;
  84.         camera_ops->auto_focus = camera_auto_focus;
  85.         camera_ops->cancel_auto_focus = camera_cancel_auto_focus;
  86.         camera_ops->take_picture = camera_take_picture;
  87.         camera_ops->cancel_picture = camera_cancel_picture;
  88.         camera_ops->set_parameters = camera_set_parameters;
  89.         camera_ops->get_parameters = camera_get_parameters;
  90.         camera_ops->put_parameters = camera_put_parameters;
  91.         camera_ops->send_command = camera_send_command;
  92.         camera_ops->release = camera_release;
  93.         camera_ops->dump = camera_dump;

  95.         *device = &camera_device->base.common;

  97.         // -------- TI specific stuff --------

  99.         camera_device->cameraid = cameraid;

  101.         if(gCameraProperties.getProperties(cameraid, &properties) < 0)
  102.         {
  103.             LOGE("Couldn't get camera properties");
  104.             rv = -ENOMEM;
  105.             goto fail;
  106.         }
  107.         ****************重点就在这里了****************
  108.         camera = new android::CameraHal(cameraid);

  110.         if(!camera)
  111.         {
  112.             LOGE("Couldn't create instance of CameraHal class");
  113.             rv = -ENOMEM;
  114.             goto fail;
  115.         }

  117.         if(properties && (camera->initialize(properties) != android::NO_ERROR))
  118.         {
  119.             LOGE("Couldn't initialize camera instance");
  120.             rv = -ENODEV;
  121.             goto fail;
  122.         }

  124.         gCameraHals[cameraid] = camera;
  125.         gCamerasOpen++;

  127.     }

  129.     return rv;

  131. fail:
  132.     if(camera_device) {
  133.         free(camera_device);
  134.         camera_device = NULL;
  135.     }
  136.     if(camera_ops) {
  137.         free(camera_ops);
  138.         camera_ops = NULL;
  139.     }
  140.     if(camera) {
  141.         delete camera;
  142.         camera = NULL;
  143.     }
  144.     *device = NULL;
  145.     return rv;
  146. }
上面横线中间的部分就是camerahal的初始化了，首先new camerahal，并且调用initialize方法，最后将实例化好的camerahal保存到gCameraHals这个数组中，之后会通过这个数组找到我们实例化好的camerahal，实现我们对hal层接口的使用
现在我们就开始看看camerahal的initialize方法的实现
  1. /**
  2.    @brief Initialize the Camera HAL

  4.    Creates CameraAdapter, AppCallbackNotifier, DisplayAdapter and MemoryManager

  6.    @param None
  7.    @return NO_ERROR - On success
  8.          NO_MEMORY - On failure to allocate memory for any of the objects
  9.    @remarks Camera Hal internal function

  11.  */

  13. status_t CameraHal::initialize(CameraProperties::Properties* properties)
  14. {
  15.     LOG_FUNCTION_NAME;

  17.     int sensor_index = 0;
  18.     const char* sensor_name = NULL;

  20.     ///Initialize the event mask used for registering an event provider for AppCallbackNotifier
  21.     ///Currently, registering all events as to be coming from CameraAdapter
  22.     int32_t eventMask = CameraHalEvent::ALL_EVENTS;

  24.     // Get my camera properties
  25.     mCameraProperties = properties;

  27.     if(!mCameraProperties)
  28.     {
  29.         goto fail_loop;
  30.     }

  32.     // Dump the properties of this Camera
  33.     // will only print if DEBUG macro is defined
  34.     mCameraProperties->dump();

  36.     if (strcmp(CameraProperties::DEFAULT_VALUE, mCameraProperties->get(CameraProperties::CAMERA_SENSOR_INDEX)) != 0 )
  37.         {
  38.         sensor_index = atoi(mCameraProperties->get(CameraProperties::CAMERA_SENSOR_INDEX));
  39.         }

  41.     if (strcmp(CameraProperties::DEFAULT_VALUE, mCameraProperties->get(CameraProperties::CAMERA_NAME)) != 0 ) {
  42.         sensor_name = mCameraProperties->get(CameraProperties::CAMERA_NAME);
  43.     }
  44.     CAMHAL_LOGDB("Sensor index= %d; Sensor name= %s", sensor_index, sensor_name);
     1.这里很重要*******************************************************************************
     这里做一个判断决定我们是使用V4LCameraAdapter还是OMXCameraAdapter
     接下来将要重点学习OMX机制，这篇文章我们假设走else分支
  1.     if (strcmp(sensor_name, V4L_CAMERA_NAME_USB) == 0) {
  2. #ifdef V4L_CAMERA_ADAPTER
  3.         mCameraAdapter = V4LCameraAdapter_Factory(sensor_index);
  4. #endif
  5.     }
  6.     else {
  7. #ifdef OMX_CAMERA_ADAPTER
  8.         mCameraAdapter = OMXCameraAdapter_Factory(sensor_index);
  9. #endif
  10.     }

  12.     if ( ( NULL == mCameraAdapter ) || (mCameraAdapter->initialize(properties)!=NO_ERROR))
  13.         {
  14.         CAMHAL_LOGEA("Unable to create or initialize CameraAdapter");
  15.         mCameraAdapter = NULL;
  16.         goto fail_loop;
  17.         }

  19.     mCameraAdapter->incStrong(mCameraAdapter);
  20.     mCameraAdapter->registerImageReleaseCallback(releaseImageBuffers, (void *) this);
  21.     mCameraAdapter->registerEndCaptureCallback(endImageCapture, (void *)this);
     2.这里很重要*****************************************************************************
     这里实例化一个AppCallbackNotifier，并且调用initialize方法进行初始化
  1.     if(!mAppCallbackNotifier.get())
  2.         {
  3.         /// Create the callback notifier
  4.         mAppCallbackNotifier = new AppCallbackNotifier();
  5.         if( ( NULL == mAppCallbackNotifier.get() ) || ( mAppCallbackNotifier->initialize() != NO_ERROR))
  6.             {
  7.             CAMHAL_LOGEA("Unable to create or initialize AppCallbackNotifier");
  8.             goto fail_loop;
  9.             }
  10.         }
     3.这里很重要*****************************************************************************
     这里实例化一个MemoryManager，并且调用initialize方法进行初始化，以及其他一些set 或者初始化
  1.     if(!mMemoryManager.get())
  2.         {
  3.         /// Create Memory Manager
  4.         mMemoryManager = new MemoryManager();
  5.         if( ( NULL == mMemoryManager.get() ) || ( mMemoryManager->initialize() != NO_ERROR))
  6.             {
  7.             CAMHAL_LOGEA("Unable to create or initialize MemoryManager");
  8.             goto fail_loop;
  9.             }
  10.         }

  12.     ///Setup the class dependencies...

  14.     ///AppCallbackNotifier has to know where to get the Camera frames and the events like auto focus lock etc from.
  15.     ///CameraAdapter is the one which provides those events
  16.     ///Set it as the frame and event providers for AppCallbackNotifier
  17.     ///@remarks setEventProvider API takes in a bit mask of events for registering a provider for the different events
  18.     /// That way, if events can come from DisplayAdapter in future, we will be able to add it as provider
  19.     /// for any event
  20.     mAppCallbackNotifier->setEventProvider(eventMask, mCameraAdapter);
  21.     mAppCallbackNotifier->setFrameProvider(mCameraAdapter);

  23.     ///Any dynamic errors that happen during the camera use case has to be propagated back to the application
  24.     ///via CAMERA_MSG_ERROR. AppCallbackNotifier is the class that notifies such errors to the application
  25.     ///Set it as the error handler for CameraAdapter
  26.     mCameraAdapter->setErrorHandler(mAppCallbackNotifier.get());

  28.     ///Start the callback notifier
  29.     if(mAppCallbackNotifier->start() != NO_ERROR)
  30.       {
  31.         CAMHAL_LOGEA("Couldn't start AppCallbackNotifier");
  32.         goto fail_loop;
  33.       }

  35.     CAMHAL_LOGDA("Started AppCallbackNotifier..");
  36.     mAppCallbackNotifier->setMeasurements(mMeasurementEnabled);
     4.这里很重要*****************************************************************************
     这里进行camera参数的设置
  1.     ///Initialize default parameters
  2.     initDefaultParameters();

  4.     if ( setParameters(mParameters) != NO_ERROR )
  5.         {
  6.         CAMHAL_LOGEA("Failed to set default parameters?!");
  7.         }
     5.这里很重要*****************************************************************************
     这里实例化一个SensorListener，并且调用initialize方法进行初始化，以及其他一些初始设置
  1.     // register for sensor events
  2.     mSensorListener = new SensorListener();
  3.     if (mSensorListener.get()) {
  4.         if (mSensorListener->initialize() == NO_ERROR) {
  5.             mSensorListener->setCallbacks(orientation_cb, this);
  6.             mSensorListener->enableSensor(SensorListener::SENSOR_ORIENTATION);
  7.         } else {
  8.             CAMHAL_LOGEA("Error initializing SensorListener. not fatal, continuing");
  9.             mSensorListener.clear();
  10.             mSensorListener = NULL;
  11.         }
  12.     }

  14.     LOG_FUNCTION_NAME_EXIT;

  16.     return NO_ERROR;

  18.     fail_loop:

  20.         ///Free up the resources because we failed somewhere up
  21.         deinitialize();
  22.         LOG_FUNCTION_NAME_EXIT;

  24.         return NO_MEMORY;

  26. }
上面一共五个步骤，接下来将一一分析，自我感觉很有这样的必要

一.OMXCameraAdapter的实例化和初始化
首先看一下OMXCameraAdapter的默认构造函数
  1. OMXCameraAdapter::OMXCameraAdapter(size_t sensor_index)
  2. {
  3.     LOG_FUNCTION_NAME;

  5.     mOmxInitialized = false;
  6.     mComponentState = OMX_StateInvalid;
  7.     mSensorIndex = sensor_index;
  8.     mPictureRotation = 0;
  9.     // Initial values
  10.     mTimeSourceDelta = 0;
  11.     onlyOnce = true;
  12.     mDccData.pData = NULL;

  14.     mInitSem.Create(0);
  15.     mFlushSem.Create(0);
  16.     mUsePreviewDataSem.Create(0);
  17.     mUsePreviewSem.Create(0);
  18.     mUseCaptureSem.Create(0);
  19.     mUseReprocessSem.Create(0);
  20.     mStartPreviewSem.Create(0);
  21.     mStopPreviewSem.Create(0);
  22.     mStartCaptureSem.Create(0);
  23.     mStopCaptureSem.Create(0);
  24.     mStopReprocSem.Create(0);
  25.     mSwitchToLoadedSem.Create(0);
  26.     mCaptureSem.Create(0);

  28.     mSwitchToExecSem.Create(0);

  30.     mCameraAdapterParameters.mHandleComp = 0;

  32.     mUserSetExpLock = OMX_FALSE;
  33.     mUserSetWbLock = OMX_FALSE;

  35.     mFramesWithDucati = 0;
  36.     mFramesWithDisplay = 0;
  37.     mFramesWithEncoder = 0;

  39. #ifdef CAMERAHAL_OMX_PROFILING

  41.     mDebugProfile = 0;

  43. #endif

  45.     LOG_FUNCTION_NAME_EXIT;
  46. }
这其中只是对很多参数的默认初始化，接下来看看initialize方法
  1. /*--------------------Camera Adapter Class STARTS here-----------------------------*/

  3. status_t OMXCameraAdapter::initialize(CameraProperties::Properties* caps)
  4. {
  5.     LOG_FUNCTION_NAME;

  7.     char value[PROPERTY_VALUE_MAX];
  8.     const char *mountOrientationString = NULL;

  10.     property_get("debug.camera.showfps", value, "0");
  11.     mDebugFps = atoi(value);
  12.     property_get("debug.camera.framecounts", value, "0");
  13.     mDebugFcs = atoi(value);

  15. #ifdef CAMERAHAL_OMX_PROFILING

  17.     property_get("debug.camera.profile", value, "0");
  18.     mDebugProfile = atoi(value);

  20. #endif

  22.     TIMM_OSAL_ERRORTYPE osalError = OMX_ErrorNone;
  23.     OMX_ERRORTYPE eError = OMX_ErrorNone;
  24.     status_t ret = NO_ERROR;

  26.     mLocalVersionParam.s.nVersionMajor = 0x1;
  27.     mLocalVersionParam.s.nVersionMinor = 0x1;
  28.     mLocalVersionParam.s.nRevision = 0x0 ;
  29.     mLocalVersionParam.s.nStep = 0x0;

  31.     mPending3Asettings = 0;//E3AsettingsAll;
  32.     mPendingCaptureSettings = 0;
  33.     mPendingPreviewSettings = 0;

  35.     if ( 0 != mInitSem.Count() )
  36.         {
  37.         CAMHAL_LOGEB("Error mInitSem semaphore count %d", mInitSem.Count());
  38.         LOG_FUNCTION_NAME_EXIT;
  39.         return NO_INIT;
  40.         }

  42.     ///Update the preview and image capture port indexes
  43.     mCameraAdapterParameters.mPrevPortIndex = OMX_CAMERA_PORT_VIDEO_OUT_PREVIEW;
  44.     // temp changed in order to build OMX_CAMERA_PORT_VIDEO_OUT_IMAGE;
  45.     mCameraAdapterParameters.mImagePortIndex = OMX_CAMERA_PORT_IMAGE_OUT_IMAGE;
  46.     mCameraAdapterParameters.mMeasurementPortIndex = OMX_CAMERA_PORT_VIDEO_OUT_MEASUREMENT;
  47.     //currently not supported use preview port instead
  48.     mCameraAdapterParameters.mVideoPortIndex = OMX_CAMERA_PORT_VIDEO_OUT_VIDEO;
  49.     mCameraAdapterParameters.mVideoInPortIndex = OMX_CAMERA_PORT_VIDEO_IN_VIDEO;
  50.     // 1.OMX_Init
  51.     eError = OMX_Init();
  52.     if (eError != OMX_ErrorNone) {
  53.         CAMHAL_LOGEB("OMX_Init() failed, error: 0x%x", eError);
  54.         return ErrorUtils::omxToAndroidError(eError);
  55.     }
  56.     mOmxInitialized = true;

  58.     // 2.Initialize the callback handles
  59.     OMX_CALLBACKTYPE callbacks;
  60.     callbacks.EventHandler = android::OMXCameraAdapterEventHandler;
  61.     callbacks.EmptyBufferDone = android::OMXCameraAdapterEmptyBufferDone;
  62.     callbacks.FillBufferDone = android::OMXCameraAdapterFillBufferDone;

  64.     // 3.Get the handle to the OMX Component
  65.     eError = OMXCameraAdapter::OMXCameraGetHandle(&mCameraAdapterParameters.mHandleComp, this, callbacks);
  66.     if(eError != OMX_ErrorNone) {
  67.         CAMHAL_LOGEB("OMX_GetHandle -0x%x", eError);
  68.     }
  69.     GOTO_EXIT_IF((eError != OMX_ErrorNone), eError);

  71.     mComponentState = OMX_StateLoaded;

  73.     CAMHAL_LOGVB("OMX_GetHandle -0x%x sensor_index = %lu", eError, mSensorIndex);
  74.     initDccFileDataSave(&mCameraAdapterParameters.mHandleComp, mCameraAdapterParameters.mPrevPortIndex);

  76.     eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp,
  77.                                   OMX_CommandPortDisable,
  78.                                   OMX_ALL,
  79.                                   NULL);

  81.     if(eError != OMX_ErrorNone) {
  82.          CAMHAL_LOGEB("OMX_SendCommand(OMX_CommandPortDisable) -0x%x", eError);
  83.     }
  84.     GOTO_EXIT_IF((eError != OMX_ErrorNone), eError);

  86.     // 4.Register for port enable event
  87.     ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
  88.                                  OMX_EventCmdComplete,
  89.                                  OMX_CommandPortEnable,
  90.                                  mCameraAdapterParameters.mPrevPortIndex,
  91.                                  mInitSem);
  92.     if(ret != NO_ERROR) {
  93.          CAMHAL_LOGEB("Error in registering for event %d", ret);
  94.          goto EXIT;
  95.     }

  97.     // 5.Enable PREVIEW Port
  98.     eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp,
  99.                                  OMX_CommandPortEnable,
  100.                                  mCameraAdapterParameters.mPrevPortIndex,
  101.                                  NULL);
  102.     if(eError != OMX_ErrorNone) {
  103.         CAMHAL_LOGEB("OMX_SendCommand(OMX_CommandPortEnable) -0x%x", eError);
  104.     }
  105.     GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);

  107.     // 6.Wait for the port enable event to occur
  108.     ret = mInitSem.WaitTimeout(OMX_CMD_TIMEOUT);
  109.     if ( NO_ERROR == ret ) {
  110.          CAMHAL_LOGDA("-Port enable event arrived");
  111.     } else {
  112.          ret |= RemoveEvent(mCameraAdapterParameters.mHandleComp,
  113.                             OMX_EventCmdComplete,
  114.                             OMX_CommandPortEnable,
  115.                             mCameraAdapterParameters.mPrevPortIndex,
  116.                             NULL);
  117.          CAMHAL_LOGEA("Timeout for enabling preview port expired!");
  118.          goto EXIT;
  119.      }

  121.     // 7.Select the sensor
  122.     OMX_CONFIG_SENSORSELECTTYPE sensorSelect;
  123.     OMX_INIT_STRUCT_PTR (&sensorSelect, OMX_CONFIG_SENSORSELECTTYPE);
  124.     sensorSelect.eSensor = (OMX_SENSORSELECT) mSensorIndex;
  125.     eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, ( OMX_INDEXTYPE ) OMX_TI_IndexConfigSensorSelect, &sensorSelect);
  126.     if ( OMX_ErrorNone != eError ) {
  127.         CAMHAL_LOGEB("Error while selecting the sensor index as %d - 0x%x", mSensorIndex, eError);
  128.         return BAD_VALUE;
  129.     } else {
  130.         CAMHAL_LOGDB("Sensor %d selected successfully", mSensorIndex);
  131.     }

  133. #ifdef CAMERAHAL_DEBUG

  135.     printComponentVersion(mCameraAdapterParameters.mHandleComp);

  137. #endif
  138.     // 8.初始化默认参数
  139.     mBracketingEnabled = false;
  140.     mZoomBracketingEnabled = false;
  141.     mBracketingBuffersQueuedCount = 0;
  142.     mBracketingRange = 1;
  143.     mLastBracetingBufferIdx = 0;
  144.     mBracketingBuffersQueued = NULL;
  145.     mOMXStateSwitch = false;
  146.     mBracketingSet = false;
  147. #ifdef CAMERAHAL_USE_RAW_IMAGE_SAVING
  148.     mRawCapture = false;
  149.     mYuvCapture = false;
  150. #endif

  152.     mCaptureSignalled = false;
  153.     mCaptureConfigured = false;
  154.     mReprocConfigured = false;
  155.     mRecording = false;
  156.     mWaitingForSnapshot = false;
  157.     mPictureFormatFromClient = NULL;

  159.     mCapabilitiesOpMode = MODE_MAX;
  160.     mCapMode = INITIAL_MODE;
  161.     mIPP = IPP_NULL;
  162.     mVstabEnabled = false;
  163.     mVnfEnabled = false;
  164.     mBurstFrames = 1;
  165.     mBurstFramesAccum = 0;
  166.     mCapturedFrames = 0;
  167.     mFlushShotConfigQueue = false;
  168.     mPictureQuality = 100;
  169.     mCurrentZoomIdx = 0;
  170.     mTargetZoomIdx = 0;
  171.     mPreviousZoomIndx = 0;
  172.     mReturnZoomStatus = false;
  173.     mZoomInc = 1;
  174.     mZoomParameterIdx = 0;
  175.     mExposureBracketingValidEntries = 0;
  176.     mZoomBracketingValidEntries = 0;
  177.     mSensorOverclock = false;
  178.     mAutoConv = OMX_TI_AutoConvergenceModeMax;
  179.     mManualConv = 0;
  180.     mDeviceOrientation = 0;
  181.     mCapabilities = caps;
  182.     mZoomUpdating = false;
  183.     mZoomUpdate = false;
  184.     mGBCE = BRIGHTNESS_OFF;
  185.     mGLBCE = BRIGHTNESS_OFF;
  186.     mParameters3A.ExposureLock = OMX_FALSE;
  187.     mParameters3A.WhiteBalanceLock = OMX_FALSE;

  189.     mEXIFData.mGPSData.mAltitudeValid = false;
  190.     mEXIFData.mGPSData.mDatestampValid = false;
  191.     mEXIFData.mGPSData.mLatValid = false;
  192.     mEXIFData.mGPSData.mLongValid = false;
  193.     mEXIFData.mGPSData.mMapDatumValid = false;
  194.     mEXIFData.mGPSData.mProcMethodValid = false;
  195.     mEXIFData.mGPSData.mVersionIdValid = false;
  196.     mEXIFData.mGPSData.mTimeStampValid = false;
  197.     mEXIFData.mModelValid = false;
  198.     mEXIFData.mMakeValid = false;

  200.     //update the mDeviceOrientation with the sensor mount orientation.
  201.     //So that the face detect will work before onOrientationEvent()
  202.     //get triggered.
  203.     CAMHAL_ASSERT(mCapabilities);
  204.     mountOrientationString = mCapabilities->get(CameraProperties::ORIENTATION_INDEX);
  205.     CAMHAL_ASSERT(mountOrientationString);
  206.     mDeviceOrientation = atoi(mountOrientationString);

  208.     if (mSensorIndex != 2) {
  209.         mCapabilities->setMode(MODE_HIGH_SPEED);
  210.     }

  212.     if (mCapabilities->get(CameraProperties::SUPPORTED_ZOOM_STAGES) != NULL) {
  213.         mMaxZoomSupported = mCapabilities->getInt(CameraProperties::SUPPORTED_ZOOM_STAGES) + 1;
  214.     } else {
  215.         mMaxZoomSupported = 1;
  216.     }

  218.     // 9.initialize command handling thread
  219.     if(mCommandHandler.get() == NULL)
  220.         mCommandHandler = new CommandHandler(this);

  222.     if ( NULL == mCommandHandler.get() )
  223.     {
  224.         CAMHAL_LOGEA("Couldn't create command handler");
  225.         return NO_MEMORY;
  226.     }

  228.     ret = mCommandHandler->run("CallbackThread", PRIORITY_URGENT_DISPLAY);
  229.     if ( ret != NO_ERROR )
  230.     {
  231.         if( ret == INVALID_OPERATION){
  232.             CAMHAL_LOGDA("command handler thread already runnning!!");
  233.             ret = NO_ERROR;
  234.         } else {
  235.             CAMHAL_LOGEA("Couldn't run command handlerthread");
  236.             return ret;
  237.         }
  238.     }

  240.     // 10.initialize omx callback handling thread
  241.     if(mOMXCallbackHandler.get() == NULL)
  242.         mOMXCallbackHandler = new OMXCallbackHandler(this);

  244.     if ( NULL == mOMXCallbackHandler.get() )
  245.     {
  246.         CAMHAL_LOGEA("Couldn't create omx callback handler");
  247.         return NO_MEMORY;
  248.     }

  250.     ret = mOMXCallbackHandler->run("OMXCallbackThread", PRIORITY_URGENT_DISPLAY);
  251.     if ( ret != NO_ERROR )
  252.     {
  253.         if( ret == INVALID_OPERATION){
  254.             CAMHAL_LOGDA("omx callback handler thread already runnning!!");
  255.             ret = NO_ERROR;
  256.         } else {
  257.             CAMHAL_LOGEA("Couldn't run omx callback handler thread");
  258.             return ret;
  259.         }
  260.     }

  262.     OMX_INIT_STRUCT_PTR (&mRegionPriority, OMX_TI_CONFIG_3A_REGION_PRIORITY);
  263.     OMX_INIT_STRUCT_PTR (&mFacePriority, OMX_TI_CONFIG_3A_FACE_PRIORITY);
  264.     mRegionPriority.nPortIndex = OMX_ALL;
  265.     mFacePriority.nPortIndex = OMX_ALL;

  267.     //Setting this flag will that the first setParameter call will apply all 3A settings
  268.     //and will not conditionally apply based on current values.
  269.     mFirstTimeInit = true;

  271.     //Flag to avoid calling setVFramerate() before OMX_SetParameter(OMX_IndexParamPortDefinition)
  272.     //Ducati will return an error otherwise.
  273.     mSetFormatDone = false;

  275.     memset(mExposureBracketingValues, 0, EXP_BRACKET_RANGE*sizeof(int));
  276.     memset(mZoomBracketingValues, 0, ZOOM_BRACKET_RANGE*sizeof(int));
  277.     mMeasurementEnabled = false;
  278.     mFaceDetectionRunning = false;
  279.     mFaceDetectionPaused = false;
  280.     mFDSwitchAlgoPriority = false;

  282.     memset(&mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex], 0, sizeof(OMXCameraPortParameters));
  283.     memset(&mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex], 0, sizeof(OMXCameraPortParameters));
  284.     memset(&mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mVideoPortIndex], 0, sizeof(OMXCameraPortParameters));
  285.     memset(&mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mVideoInPortIndex], 0, sizeof(OMXCameraPortParameters));

  287.     // 11.initialize 3A defaults
  288.     mParameters3A.Effect = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_EFFECT, EffLUT);
  289.     mParameters3A.FlashMode = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_FLASH_MODE, FlashLUT);
  290.     mParameters3A.SceneMode = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_SCENE_MODE, SceneLUT);
  291.     mParameters3A.EVCompensation = atoi(OMXCameraAdapter::DEFAULT_EV_COMPENSATION);
  292.     mParameters3A.Focus = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_FOCUS_MODE, FocusLUT);
  293.     mParameters3A.ISO = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_ISO_MODE, IsoLUT);
  294.     mParameters3A.Flicker = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_ANTIBANDING, FlickerLUT);
  295.     mParameters3A.Brightness = atoi(OMXCameraAdapter::DEFAULT_BRIGHTNESS);
  296.     mParameters3A.Saturation = atoi(OMXCameraAdapter::DEFAULT_SATURATION) - SATURATION_OFFSET;
  297.     mParameters3A.Sharpness = atoi(OMXCameraAdapter::DEFAULT_SHARPNESS) - SHARPNESS_OFFSET;
  298.     mParameters3A.Contrast = atoi(OMXCameraAdapter::DEFAULT_CONTRAST) - CONTRAST_OFFSET;
  299.     mParameters3A.WhiteBallance = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_WB, WBalLUT);
  300.     mParameters3A.Exposure = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_EXPOSURE_MODE, ExpLUT);
  301.     mParameters3A.ExposureLock = OMX_FALSE;
  302.     mParameters3A.FocusLock = OMX_FALSE;
  303.     mParameters3A.WhiteBalanceLock = OMX_FALSE;

  305.     mParameters3A.ManualExposure = 0;
  306.     mParameters3A.ManualExposureRight = 0;
  307.     mParameters3A.ManualGain = 0;
  308.     mParameters3A.ManualGainRight = 0;

  310.     mParameters3A.AlgoFixedGamma = OMX_TRUE;
  311.     mParameters3A.AlgoNSF1 = OMX_TRUE;
  312.     mParameters3A.AlgoNSF2 = OMX_TRUE;
  313.     mParameters3A.AlgoSharpening = OMX_TRUE;
  314.     mParameters3A.AlgoThreeLinColorMap = OMX_TRUE;
  315.     mParameters3A.AlgoGIC = OMX_TRUE;

  317.     LOG_FUNCTION_NAME_EXIT;
  318.     return ErrorUtils::omxToAndroidError(eError);

  320.     EXIT:

  322.     CAMHAL_LOGDB("Exiting function %s because of ret %d eError=%x", __FUNCTION__, ret, eError);
  323.     performCleanupAfterError();
  324.     LOG_FUNCTION_NAME_EXIT;
  325.     return ErrorUtils::omxToAndroidError(eError);
  326. }
这个initialize的过程做的事情还是比较多的，这里关系到OMX的很多知识点，是之后要研究的，现在只是先知道这里
在完成initialize方法之后，
mCameraAdapter->registerImageReleaseCallback(releaseImageBuffers, (void *) this);
mCameraAdapter->registerEndCaptureCallback(endImageCapture, (void *)this);
这两个方法同样非常重要，首先我们这里调用的是mCameraAdapter的方法， mCameraAdapter是OMXCameraAdapter这个类的实例，但是其实 OMXCameraAdapter这个类中是没有以上这两个方法的，但是我们接着看， OMXCameraAdapter这个类的定义
class OMXCameraAdapter : public BaseCameraAdapter
OMXCameraAdapter继承于BaseCameraAdapter，不错，上面的两个方法是在 BaseCameraAdapter这个类中实现的，我们接着看看
  1. status_t BaseCameraAdapter::registerImageReleaseCallback(release_image_buffers_callback callback, void *user_data)
  2. {
  3.     status_t ret = NO_ERROR;

  5.     LOG_FUNCTION_NAME;

  7.     mReleaseImageBuffersCallback = callback;
  8.     mReleaseData = user_data;

  10.     LOG_FUNCTION_NAME_EXIT;

  12.     return ret;
  13. }

  15. status_t BaseCameraAdapter::registerEndCaptureCallback(end_image_capture_callback callback, void *user_data)
  16. {
  17.     status_t ret = NO_ERROR;

  19.     LOG_FUNCTION_NAME;

  21.     mEndImageCaptureCallback= callback;
  22.     mEndCaptureData = user_data;

  24.     LOG_FUNCTION_NAME_EXIT;

  26.     return ret;
  27. }
这两个方法实现方式一模一样，只是将传入的函数指针和user_data保存到其中而已
mEndImageCaptureCallback这个方法会在OMXCameraAdapter的fillThisBuffer中被调用，他的实现在
  1. void releaseImageBuffers(void *userData)
  2. {
  3.     LOG_FUNCTION_NAME;

  5.     if (NULL != userData) {
  6.         CameraHal *c = reinterpret_cast<CameraHal *>(userData);//user_data就是指向我们实例化的OMXCameraAdapter变量mCameraAdapter
  7.         c->freeImageBufs();//接着调用mCameraAdapter的freeImageBufs方法
  8.     }

  10.     LOG_FUNCTION_NAME_EXIT;
  11. }
  1. status_t CameraHal::freeImageBufs()
  2. {
  3.     status_t ret = NO_ERROR;

  5.     LOG_FUNCTION_NAME;

  7.     if ( NO_ERROR == ret )
  8.         {

  10.         if( NULL != mImageBufs )
  11.             {

  13.             ///@todo Pluralise the name of this method to freeBuffers
  14.             ret = mMemoryManager->freeBuffer(mImageBufs);//通过memoryManager释放内存
  15.             mImageBufs = NULL;

  17.             }
  18.         else
  19.             {
  20.             ret = -EINVAL;
  21.             }

  23.         }

  25.     LOG_FUNCTION_NAME_EXIT;

  27.     return ret;
  28. }
mReleaseImageBuffersCallback 这个方法将在OMXCapture.cpp中被调用，他的实现和上面是相似的，就不再说了

二.AppCallbackNotifier的实例化和初始化
AppCallbackNotifier这个类是没有实现构造函数的，我们就先看看他的initialize方法吧
  1. /**
  2.   * NotificationHandler class
  3.   */

  5. ///Initialization function for AppCallbackNotifier
  6. status_t AppCallbackNotifier::initialize()
  7. {
  8.     LOG_FUNCTION_NAME;

  10.     mPreviewMemory = 0;

  12.     mMeasurementEnabled = false;

  14.     mNotifierState = NOTIFIER_STOPPED;

  16.     ///Create the app notifier thread
  17.     mNotificationThread = new NotificationThread(this);
  18.     if(!mNotificationThread.get())
  19.         {
  20.         CAMHAL_LOGEA("Couldn't create Notification thread");
  21.         return NO_MEMORY;
  22.         }

  24.     ///Start the display thread
  25.     status_t ret = mNotificationThread->run("NotificationThread", PRIORITY_URGENT_DISPLAY);
  26.     if(ret!=NO_ERROR)
  27.         {
  28.         CAMHAL_LOGEA("Couldn't run NotificationThread");
  29.         mNotificationThread.clear();
  30.         return ret;
  31.         }

  33.     mUseMetaDataBufferMode = true;
  34.     mRawAvailable = false;

  36.     mRecording = false;
  37.     mPreviewing = false;

  39.     LOG_FUNCTION_NAME_EXIT;

  41.     return ret;
  42. }
这个initialize方法做的事情相对简单但是有及其重要，他创建了一个notificationthread，然后运行这个thread
这里我们看看这个很忙碌的线程都干了些什么事情，之所以说他忙碌，是因为他一直不停的等待消息，有消息就处理，不能磨叽磨叽的

  1. bool AppCallbackNotifier::notificationThread()
  2. {
  3.     bool shouldLive = true;
  4.     status_t ret;

  6.     LOG_FUNCTION_NAME;

  8.     //CAMHAL_LOGDA("Notification Thread waiting for message");
  9.     ret = TIUTILS::MessageQueue::waitForMsg(&mNotificationThread->msgQ(),
  10.                                             &mEventQ,
  11.                                             &mFrameQ,
  12.                                             AppCallbackNotifier::NOTIFIER_TIMEOUT);

  14.     //CAMHAL_LOGDA("Notification Thread received message");
  15.     //上面等待message，消息到来时开始往下运行，之后区分这些消息到底是什么消息，就像邮局收到邮件接着往下分发一样
  16.     if (mNotificationThread->msgQ().hasMsg()) {
  17.         ///Received a message from CameraHal, process it
  18.         CAMHAL_LOGDA("Notification Thread received message from Camera HAL");
  19.         shouldLive = processMessage();//先进行消息的筛选，这里跳出有问题的邮件抛弃掉，收到NOTIFIER_EXIT消息则退出
  20.         if(!shouldLive) {
  21.           CAMHAL_LOGDA("Notification Thread exiting.");
  22.           return shouldLive;
  23.         }
  24.     }

  26.     if(mEventQ.hasMsg()) {
  27.         ///Received an event from one of the event providers
  28.         CAMHAL_LOGDA("Notification Thread received an event from event provider (CameraAdapter)");
  29.         notifyEvent();//分类完成就分类处理了，这里是enent 事件的处理
  30.      }

  32.     if(mFrameQ.hasMsg()) {
  33.        ///Received a frame from one of the frame providers
  34.        //CAMHAL_LOGDA("Notification Thread received a frame from frame provider (CameraAdapter)");
  35.        notifyFrame();//分类完成就分类处理了，这里是frame 事件的处理
  36.     }

  38.     LOG_FUNCTION_NAME_EXIT;
  39.     return shouldLive;
  40. }
这里先看一下notifyEvent方法的处理过程：
  1. void AppCallbackNotifier::notifyEvent()
  2. {
  3.     ///Receive and send the event notifications to app
  4.     TIUTILS::Message msg;
  5.     LOG_FUNCTION_NAME;
  6.     {
  7.         Mutex::Autolock lock(mLock);
  8.         if ( !mEventQ.hasMsg() ) {
  9.             return;
  10.         } else {
  11.             mEventQ.get(&msg);
  12.         }
  13.     }
  14.     bool ret = true;
  15.     CameraHalEvent *evt = NULL;
  16.     CameraHalEvent::FocusEventData *focusEvtData;
  17.     CameraHalEvent::ZoomEventData *zoomEvtData;
  18.     CameraHalEvent::MetaEventData metaEvtData;

  20.     if(mNotifierState != AppCallbackNotifier::NOTIFIER_STARTED)
  21.     {
  22.         return;
  23.     }

  25.     switch(msg.command)
  26.         {
  27.         case AppCallbackNotifier::NOTIFIER_CMD_PROCESS_EVENT:

  29.             evt = ( CameraHalEvent * ) msg.arg1;

  31.             if ( NULL == evt )
  32.                 {
  33.                 CAMHAL_LOGEA("Invalid CameraHalEvent");
  34.                 return;
  35.                 }

  37.             switch(evt->mEventType)
  38.                 {
  39.                 case CameraHalEvent::EVENT_SHUTTER:

  41.                     if ( ( NULL != mCameraHal ) &&
  42.                           ( NULL != mNotifyCb ) &&
  43.                           ( mCameraHal->msgTypeEnabled(CAMERA_MSG_SHUTTER) ) )
  44.                         {
  45.                             mNotifyCb(CAMERA_MSG_SHUTTER, 0, 0, mCallbackCookie);
  46.                         }
  47.                     mRawAvailable = false;

  49.                     break;

  51.                 case CameraHalEvent::EVENT_FOCUS_LOCKED:
  52.                 case CameraHalEvent::EVENT_FOCUS_ERROR:

  54.                     focusEvtData = &evt->mEventData->focusEvent;
  55.                     if ( ( focusEvtData->focusStatus == CameraHalEvent::FOCUS_STATUS_SUCCESS ) &&
  56.                             ( NULL != mCameraHal ) &&
  57.                             ( NULL != mNotifyCb ) &&
  58.                             ( mCameraHal->msgTypeEnabled(CAMERA_MSG_FOCUS) ) ) {
  59.                          mCameraHal->disableMsgType(CAMERA_MSG_FOCUS);
  60.                          mNotifyCb(CAMERA_MSG_FOCUS, true, 0, mCallbackCookie);
  61.                     } else if ( ( focusEvtData->focusStatus == CameraHalEvent::FOCUS_STATUS_FAIL ) &&
  62.                              ( NULL != mCameraHal ) &&
  63.                              ( NULL != mNotifyCb ) &&
  64.                              ( mCameraHal->msgTypeEnabled(CAMERA_MSG_FOCUS) ) ) {
  65.                          mCameraHal->disableMsgType(CAMERA_MSG_FOCUS);
  66.                          mNotifyCb(CAMERA_MSG_FOCUS, false, 0, mCallbackCookie);
  67.                     }

  69.                     break;

  71.                 case CameraHalEvent::EVENT_ZOOM_INDEX_REACHED:

  73.                     zoomEvtData = &evt->mEventData->zoomEvent;

  75.                     if ( ( NULL != mCameraHal ) &&
  76.                          ( NULL != mNotifyCb) &&
  77.                          ( mCameraHal->msgTypeEnabled(CAMERA_MSG_ZOOM) ) )
  78.                         {
  79.                         mNotifyCb(CAMERA_MSG_ZOOM, zoomEvtData->currentZoomIndex, zoomEvtData->targetZoomIndexReached, mCallbackCookie);
  80.                         }

  82.                     break;

  84.                 case CameraHalEvent::EVENT_METADATA:

  86.                     metaEvtData = evt->mEventData->metadataEvent;

  88.                     if ( ( NULL != mCameraHal ) &&
  89.                          ( NULL != mNotifyCb) &&
  90.                          ( mCameraHal->msgTypeEnabled(CAMERA_MSG_PREVIEW_METADATA) ) )
  91.                         {
  92.                         // WA for an issue inside CameraService
  93.                         camera_memory_t *tmpBuffer = mRequestMemory(-1, 1, 1, NULL);

  95.                         mDataCb(CAMERA_MSG_PREVIEW_METADATA,
  96.                                 tmpBuffer,
  97.                                 0,
  98.                                 metaEvtData->getMetadataResult(),
  99.                                 mCallbackCookie);

  101.                         metaEvtData.clear();

  103.                         if ( NULL != tmpBuffer ) {
  104.                             tmpBuffer->release(tmpBuffer);
  105.                         }

  107.                         }

  109.                     break;

  111.                 case CameraHalEvent::ALL_EVENTS:
  112.                     break;
  113.                 default:
  114.                     break;
  115.                 }

  117.             break;
  118.         }

  120.     if ( NULL != evt )
  121.         {
  122.         delete evt;
  123.         }


  126.     LOG_FUNCTION_NAME_EXIT;

  128. }
针对每个不同消息处理方法基本是相同的，主要通过上次register好的callback方法，这个之前已经在文章中说过，不在多做说明
这里还是比较重要的，但不是这篇文章的重点，之后有机会还会在说
再看一下 notifyFrame的处理过程：
算了，我还是不把他的处理过程贴出来，怕吓到人，挺庞大的，处理了很多事件，当然重要，先知道，再看吧

这里你处理了notifyEvent和notifyFrame这里消息，但是这些消息是从哪里来呢？知道了接收者，那么就必须找到发送者
mAppCallbackNotifier->setEventProvider(eventMask, mCameraAdapter);
mAppCallbackNotifier->setFrameProvider(mCameraAdapter);
不错，就是在这里指定了enent和frame消息的提供者（provider）
先看看setEventProvider的实现
  1. void AppCallbackNotifier::setEventProvider(int32_t eventMask, MessageNotifier * eventNotifier)
  2. {

  4.     LOG_FUNCTION_NAME;
  5.     ///@remarks There is no NULL check here. We will check
  6.     ///for NULL when we get start command from CameraHal
  7.     ///@Remarks Currently only one event provider (CameraAdapter) is supported
  8.     ///@todo Have an array of event providers for each event bitmask
  9.     mEventProvider = new EventProvider(eventNotifier, this, eventCallbackRelay);
  10.     if ( NULL == mEventProvider )
  11.         {
  12.         CAMHAL_LOGEA("Error in creating EventProvider");
  13.         }
  14.     else
  15.         {
  16.         mEventProvider->enableEventNotification(eventMask);
  17.         }

  19.     LOG_FUNCTION_NAME_EXIT;
  20. }
实例化了一个EnentProvider的对象，并且enable EventNotification
再看看setFrameProvider的实现吧
  1. void AppCallbackNotifier::setFrameProvider(FrameNotifier *frameNotifier)
  2. {
  3.     LOG_FUNCTION_NAME;
  4.     ///@remarks There is no NULL check here. We will check
  5.     ///for NULL when we get the start command from CameraAdapter
  6.     mFrameProvider = new FrameProvider(frameNotifier, this, frameCallbackRelay);
  7.     if ( NULL == mFrameProvider )
  8.         {
  9.         CAMHAL_LOGEA("Error in creating FrameProvider");
  10.         }
  11.     else
  12.         {
  13.         //Register only for captured images and RAW for now
  14.         //TODO: Register for and handle all types of frames
  15.         mFrameProvider->enableFrameNotification(CameraFrame::IMAGE_FRAME);
  16.         mFrameProvider->enableFrameNotification(CameraFrame::RAW_FRAME);
  17.         }

  19.     LOG_FUNCTION_NAME_EXIT;
  20. }
方法基本一致，实例化一个FrameProvider的对象，并且enable FrameNotification
但是这里必须分析一下FrameProvider的构造方法
  1. FrameProvider(FrameNotifier *fn, void* cookie, frame_callback frameCallback)
  2.         :mFrameNotifier(fn), mCookie(cookie),mFrameCallback(frameCallback) { }
这里通过传入的参数实例化了mFrameNotifier，初始化了mCookie，初始化了mFrameCallback，看似没什么却至关只要啊，后面你会知道的，同样EventProvider同样的

FrameProvider和EnentProvider接口的实现在CameraHalUtilClasses.cpp文件
接着往下走：Start the callback notifier
mAppCallbackNotifier->start()
  1. status_t AppCallbackNotifier::start()
  2. {
  3.     LOG_FUNCTION_NAME;
  4.     if(mNotifierState==AppCallbackNotifier::NOTIFIER_STARTED)
  5.         {
  6.         CAMHAL_LOGDA("AppCallbackNotifier already running");
  7.         LOG_FUNCTION_NAME_EXIT;
  8.         return ALREADY_EXISTS;
  9.         }

  11.     ///Check whether initial conditions are met for us to start
  12.     ///A frame provider should be available, if not return error
  13.     if(!mFrameProvider)
  14.         {
  15.         ///AppCallbackNotifier not properly initialized
  16.         CAMHAL_LOGEA("AppCallbackNotifier not properly initialized - Frame provider is NULL");
  17.         LOG_FUNCTION_NAME_EXIT;
  18.         return NO_INIT;
  19.         }

  21.     ///At least one event notifier should be available, if not return error
  22.     ///@todo Modify here when there is an array of event providers
  23.     if(!mEventProvider)
  24.         {
  25.         CAMHAL_LOGEA("AppCallbackNotifier not properly initialized - Event provider is NULL");
  26.         LOG_FUNCTION_NAME_EXIT;
  27.         ///AppCallbackNotifier not properly initialized
  28.         return NO_INIT;
  29.         }

  31.     mNotifierState = AppCallbackNotifier::NOTIFIER_STARTED;
  32.     CAMHAL_LOGDA(" --> AppCallbackNotifier NOTIFIER_STARTED \n");

  34.     gEncoderQueue.clear();

  36.     LOG_FUNCTION_NAME_EXIT;

  38.     return NO_ERROR;

  40. }
只是做了一下检查，最后clear了编码队列
接着走：mAppCallbackNotifier->setMeasurements
  1. void AppCallbackNotifier::setMeasurements(bool enable)
  2. {
  3.     Mutex::Autolock lock(mLock);

  5.     LOG_FUNCTION_NAME;

  7.     mMeasurementEnabled = enable;

  9.     if ( enable )
  10.         {
  11.          mFrameProvider->enableFrameNotification(CameraFrame::FRAME_DATA_SYNC);
  12.         }

  14.     LOG_FUNCTION_NAME_EXIT;
  15. }
AppCallbackNotifier对象实例化以及初始化到这里完成了

三.MemoryManager的实例化和初始化
无疑这个类跟内存有着很密切的关系，这个定义了自己的构造函数，但是这里不说了，是在大财小用了，只一条语句，直接看看他的initialize方法吧
  1. status_t MemoryManager::initialize() {
  2.     if ( mIonFd == -1 ) {
  3.         mIonFd = ion_open();
  4.         if ( mIonFd < 0 ) {
  5.             CAMHAL_LOGE("ion_open() failed, error: %d", mIonFd);
  6.             mIonFd = -1;
  7.             return NO_INIT;
  8.         }
  9.     }

  11.     return OK;
  12. }
只是调用了 ion_open这个方法获得了一个fd
  1. int ion_open()
  2. {
  3.         int fd = open("/dev/ion", O_RDWR);
  4.         if (fd < 0)
  5.                 LOGE("open /dev/ion failed!\n");
  6.         return fd;
  7. }
开始时我晕了，ion到底是什么device啊？赶紧查一查
这里我不做过多说明，可以看看这个分享，同时感谢大牛的分享： http://blog.csdn.net/melody_lu123/article/details/7556820
ION与PMEM类似，管理一或多个内存池，其中有一些会在boot time的时候预先分配，以备给特殊的硬件使用（GPU，显示控制器等）。它通过ION heaps来管理这些pool。
它可以被userspace的process之间或者内核中的模块之间进行内存共享

四.SensorListener的实例化和初始化
在SensorListener的构造函数中对一些参数进行了默认初始化，这里不知说明，直接看看他的initialize方法实现
  1. status_t SensorListener::initialize() {
  2.     status_t ret = NO_ERROR;
  3.     SensorManager& mgr(SensorManager::getInstance());

  5.     LOG_FUNCTION_NAME;

  7.     sp<Looper> mLooper;

  9.     mSensorEventQueue = mgr.createEventQueue();
  10.     if (mSensorEventQueue == NULL) {
  11.         CAMHAL_LOGEA("createEventQueue returned NULL");
  12.         ret = NO_INIT;
  13.         goto out;
  14.     }

  16.     mLooper = new Looper(false);
  17.     mLooper->addFd(mSensorEventQueue->getFd(), 0, ALOOPER_EVENT_INPUT, sensor_events_listener, this);

  19.     if (mSensorLooperThread.get() == NULL)
  20.             mSensorLooperThread = new SensorLooperThread(mLooper.get());

  22.     if (mSensorLooperThread.get() == NULL) {
  23.         CAMHAL_LOGEA("Couldn't create sensor looper thread");
  24.         ret = NO_MEMORY;
  25.         goto out;
  26.     }

  28.     ret = mSensorLooperThread->run("sensor looper thread", PRIORITY_URGENT_DISPLAY);
  29.     if (ret == INVALID_OPERATION){
  30.         CAMHAL_LOGDA("thread already running ?!?");
  31.     } else if (ret != NO_ERROR) {
  32.         CAMHAL_LOGEA("couldn't run thread");
  33.         goto out;
  34.     }

  36.  out:
  37.     LOG_FUNCTION_NAME_EXIT;
  38.     return ret;
  39. }
看到这里我个人是感觉这里挺抽象的，这里先简单说明一下，这里首先获取到SensorManager，通过这个 SensorManager创建一个EventQueue，然后实例化一个Looper对象，将这个EventQueue的fd添加到mLooper中，最后创建一个SensorLooperThread，并启动这个线程
下一步：mSensorListener->setCallbacks(orientation_cb, this);
  1. void SensorListener::setCallbacks(orientation_callback_t orientation_cb, void *cookie) {
  2.     LOG_FUNCTION_NAME;

  4.     if (orientation_cb) {
  5.         mOrientationCb = orientation_cb;
  6.     }
  7.     mCbCookie = cookie;

  9.     LOG_FUNCTION_NAME_EXIT;
  10. }
这里的方法跟上面讲过的setcallback方法其实基本是相通的，注册的这个回调函数是在以下方法中被调用到的
  1. void SensorListener::handleOrientation(uint32_t orientation, uint32_t tilt) {
  2.     LOG_FUNCTION_NAME;

  4.     Mutex::Autolock lock(&mLock);

  6.     if (mOrientationCb && (sensorsEnabled & SENSOR_ORIENTATION)) {
  7.         mOrientationCb(orientation, tilt, mCbCookie);
  8.     }

  10.     LOG_FUNCTION_NAME_EXIT;
  11. }
也就低调用一下方法：

  1. static void orientation_cb(uint32_t orientation, uint32_t tilt, void* cookie) {
  2.     CameraHal *camera = NULL;

  4.     if (cookie) {
  5.         camera = (CameraHal*) cookie;//这个cookie（this）指向我们实例化mCameraAdapter
  6.         camera->onOrientationEvent(orientation, tilt);//调用mCameraHal的onOrientationEvent方法
  7.     }

  9. }
我们接着跟踪下去：
  1. /**
  2.   Callback function to receive orientation events from SensorListener
  3.  */
  4. void CameraHal::onOrientationEvent(uint32_t orientation, uint32_t tilt) {
  5.     LOG_FUNCTION_NAME;

  7.     if ( NULL != mCameraAdapter ) {
  8.         mCameraAdapter->onOrientationEvent(orientation, tilt);
  9.     }

  11.     LOG_FUNCTION_NAME_EXIT;
  12. }
继续，实现在OMXCameraAdapter中
  1. void OMXCameraAdapter::onOrientationEvent(uint32_t orientation, uint32_t tilt)
  2. {
  3.     LOG_FUNCTION_NAME;

  5.     static const unsigned int DEGREES_TILT_IGNORE = 45;

  7.     // if tilt angle is greater than DEGREES_TILT_IGNORE
  8.     // we are going to ignore the orientation returned from
  9.     // sensor. the orientation returned from sensor is not
  10.     // reliable. Value of DEGREES_TILT_IGNORE may need adjusting
  11.     if (tilt > DEGREES_TILT_IGNORE) {
  12.         return;
  13.     }

  15.     int mountOrientation = 0;
  16.     bool isFront = false;
  17.     if (mCapabilities) {
  18.         const char * const mountOrientationString =
  19.                 mCapabilities->get(CameraProperties::ORIENTATION_INDEX);
  20.         if (mountOrientationString) {
  21.             mountOrientation = atoi(mountOrientationString);
  22.         }

  24.         const char * const facingString = mCapabilities->get(CameraProperties::FACING_INDEX);
  25.         if (facingString) {
  26.             isFront = strcmp(facingString, TICameraParameters::FACING_FRONT) == 0;
  27.         }
  28.     }

  30.     // direction is a constant sign for facing, meaning the rotation direction relative to device
  31.     // +1 (clockwise) for back sensor and -1 (counter-clockwise) for front sensor
  32.     const int direction = isFront ? -1 : 1;

  34.     int rotation = mountOrientation + direction*orientation;

  36.     // crop the calculated value to [0..360) range
  37.     while ( rotation < 0 ) rotation += 360;
  38.     rotation %= 360;

  40.     if (rotation != mDeviceOrientation) {
  41.         mDeviceOrientation = rotation;

  43.         // restart face detection with new rotation
  44.         setFaceDetectionOrientation(mDeviceOrientation);
  45.     }
  46.     CAMHAL_LOGVB("orientation = %d tilt = %d device_orientation = %d", orientation, tilt, mDeviceOrientation);

  48.     LOG_FUNCTION_NAME_EXIT;
  49. }
这里暂时不做分析

最后一步：mSensorListener->enableSensor(SensorListener::SENSOR_ORIENTATION)
  1. void SensorListener::enableSensor(sensor_type_t type) {
  2.     Sensor const* sensor;
  3.     SensorManager& mgr(SensorManager::getInstance());

  5.     LOG_FUNCTION_NAME;

  7.     Mutex::Autolock lock(&mLock);

  9.     if ((type & SENSOR_ORIENTATION) && !(sensorsEnabled & SENSOR_ORIENTATION)) {
  10.         sensor = mgr.getDefaultSensor(Sensor::TYPE_ACCELEROMETER);
  11.         CAMHAL_LOGDB("orientation = %p (%s)", sensor, sensor->getName().string());
  12.         mSensorEventQueue->enableSensor(sensor);
  13.         mSensorEventQueue->setEventRate(sensor, ms2ns(100));
  14.         sensorsEnabled |= SENSOR_ORIENTATION;
  15.     }

  17.     LOG_FUNCTION_NAME_EXIT;
  18. }
使能sensor
到这里为止CameraHal的这个初始化过程完成了，这里个人感觉十分重要，其他的接口实现固然重要，但是清清楚楚的知道这个初始化过程会让你hal与上层和底层的交互先有一个大体的认知，这比你一头扎进去到处乱撞要高效很多

Android Camere Study 待续。。。。
zhaohc_nj
关注
高通sdm660android9.0平台camera HAL1中获取并修改预览数据
weixin_51115260的博客
05-25 1325
前言： 最近在做一个有关于HDMI IN的需求，需要找到传入数据的buffer地址，方便以后如果有修改数据的需求的话，可以快速实现，参考了很多人的博客，在此记录一下寻找的过程，一点愚见，希望大家多多指教。 手上平台使用的是HAL1。 参考： android Camera API1+HAL1 open camera流程 & Android M_徐而思齐的博客-CSDN博客 android camera mmap,Android Camera 流程学习记录（四）—— Camera.startP
Android Camera HAL浅析
Android8.x和Android9.x平台user版本打开UART输出并支持控制台输入和user版本adb root的方法
03-30 583
Android Camera框架 Android的Camera子系统提供一个拍照和录制视频的框架。 它将Camera的上层应用与Application Framework、用户库串接起来，而正是这个用户库来与Camera的硬件层通信，从而实现操作camera硬件。 Camera HAL层部分 源码平台：rk3288 代码存放目录：hardware/rockchip/ca...
Camera.cpp层直接操作库源码，在Android8.1 sdk源码环境下编译通过
11-23
Camera.cpp层直接操作库源码，在Android8.1 sdk源码环境下编译通过
Android Camera CameraHal.cpp 分析
Seal--学海无涯
04-22 1658
Android Camera CameraHal.cpp 分析 作为上层和底层的中转站，hal层在android中起到的作用不言而喻，针对camera的研究已经有一段时间了，这里自己还是决定静下心来好好的分析一下CameraHal.cpp这里的代码， 对自己更好的理解hal与上层和底层的交互作用不可小觑，特别对理解hal与kernel driver的交互过程作用很大 不多说废话了，开始今
Camera.cpp
让阳光照进心里
11-19 1562
#include "Camera.h" #include // 初始情况下将摄像机放置在同世界坐标轴重合 Camera ::Camera(float fov, float viewPortWidth, float viewPortHeight) { position.x = 0 ; position.y = 0 ; position.z = 0 ; direction.x = 0
Android Camera从App层到framework层到HAL层的初始化过程
热门推荐
hutongling的博客
08-10 1万+
Android camera 从上到下可以分为四个部分： Application层、 framework层、 HAL（hardware abstract layer）层、 Kernel层 一般面向开发者的话主要集中在Application层和framework层，但是一些厂商需要定制一些属于自己特有的东西的时候会去修改HAL层集成自己的一些东西，至于Kernel层一般的开发人员不会涉及到。
Android R camera Hal启动（上）
weixin_53065050的博客
09-30 1835
文章目录前言代码流程分析总结 前言 之前准备按照camera APP调用API1/2的接口一点点的写代码流程。本地写了几篇之后发现不把camera server和hal的初始化写完，直接开始写API调用流程的话不太好写。还是从服务的初始化开始写吧。 代码流程分析 我就按照自己习惯的学习一个新的模块的思路来写。 先通过ps命令看一下当前camera hal运行的进程叫什么。 cameraserver 946 1 0 S android.hardware.camera.provider@2
【SPRD CAMERA】1 HAL层初始化流程
weixin_37303427的博客
06-24 1582
参考这篇文章https://www.cnblogs.com/programandriod/p/13868578.html 根据我的理解以前android在启动camera service 会直接去操作hal层，这样hal层和framework就耦合在一起了。现在 Android O 中， 加入了Camera Provider这一抽象层，该层作为一个独立进程存在于整个系统中，并且通过HIDL这一自定义语言成功地将Camera Hal Module从Camera Service中解...
fsl Camera调试第二篇 CameraHal.cpp
houyizi337825770的专栏
12-26 1825
CameraHal.cpp文件需要修改；一般CameraModule.cpp的调用函数实际都是CameraHal.cpp实现的； CAMERA_HAL_RET CameraHal :: setCaptureDevice(sp capturedevice) { CAMERA_LOG_FUNC; CAMERA_HAL_RET ret = CAMERA_HAL_
camera hal 初始加载
拒绝背八股文
05-16 1078
http://www.cnblogs.com/xerrard/p/4747802.html Android 5.1 Camera 架构学习(一)——Camera初始化 frameworks\base\core\java\android\hardware\camera.java public native final void startPreview(); and...
android camera 工作原理,Android Camera 流程学习记录（一）—— Camera 基本架构
weixin_36050866的博客
05-26 210
Camera 架构NOTE：这是 Android Camera API 1 的相关架构。Camera 的架构与 Android 整体架构是保持一致的：Framework ： Camera.javaAndroid Runtime : android_hardware_Camera.cppLibrary :Client (Camera.cpp, ICameraClient.cpp, etc...)Se...
Android 8.0系统源码分析--openCamera（HAL）启动过程源码分析
转载和创作优秀的博客
12-30 943
前面我们详细分析了从应用层调用CameraManager的openCamera的方法来打开相机的逻辑，上次的分析我们来到了CameraServer进程当中，但是还没有真正看到open操作设备节点来实现真正打开的逻辑，遗留的问题也就是从frameworks\av\services\camera\libcameraservice\device3\Camera3Device.cpp文件中的status_t Camera3Device::initialize(sp<CameraProviderManager&
Camera Open 流程源码分析，阿里p7面试流程
最新发布
2401_84024576的博客
04-09 426
最后为了帮助大家深刻理解Android相关知识点的原理以及面试相关知识，这里放上相关的我搜集整理的Android开发中高级必知必会核心笔记，共计2968页PDF、58w字，囊括Android开发648个知识点，我把技术点整理成了视频和PDF（实际上比预期多花了不少精力），包知识脉络 + 诸多细节。网上学习 Android的资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。希望这份系统化的技术体系对大家有一个方向参考。
android8 Camera2 从 CameraService 到 HAL Service
转载和创作优秀的博客
12-06 1407
上回讲到，在 CameraService::makeClient 中，实例化了一个 CameraDeviceClient。现在我们就从它的构造函数开始，继续探索打开相机的流程。 这一部分主要活动在 Runtime 层，这里分成 CameraService 与 HAL Service 两侧来分析。 接前一篇文章，最后部分 *client = new CameraDeviceClient(cameraService, tmp, packageName, cameraId, ...
camx框架-Camera初始化
linken_yue的博客
05-17 3884
1. camera provider 目录：hardware/interfaces/camera/ service.cpp->cameraprovider_2_4.cpp(HIDL_FETCH_ICameraProvider)->HIDL_FETCH_ICameraProvider->new CameraProvider<IMPL>()->LegacyCameraProviderImpl_2_4.cpp（LegacyCameraProviderImpl_2_4::..
[RK3288][Android6.0] 调试笔记 --- Camera Preview测试用例
Kris Fei's blog
06-01 2507
Platform: RK3288 OS: Android 6.0 Kernel: 3.10.92 说明： 1.打开就预览 2. button用于控制是开启preview callback并保存为jpg 源代码： package com.example.camerapreviewtest; import android.content.Context; import...
Android Camera HAL 深入探索：USB摄像头集成指南
这些文件包括`CameraHardwareStub.cpp`, `CameraHardwareStub.h`, `FakeCamera.cpp` 和 `FakeCamera.h`。 2. **创建CameraHAL目录** 在`hardware`目录下创建一个新的目录，例如`CameraHAL`，并将上述提到的模拟...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值