程序博客网 > 你懂的网址 知乎

Android Camera CameraHal.cpp 分析

来源：互联网 发布：你懂的网址 知乎 编辑：程序博客网 时间：2024/05/08 17:03
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 待续。。。。
0 0
你懂的网址 知乎 你懂的网址 知乎
原创粉丝点击
热门IT博客
mac版的visual studiomac版的visual studio
ppt辅助软件ppt辅助软件
淘宝手机端轮播图尺寸
对网络安全技术的认识
cam编程视频
特许网络的组织结构
淘宝买家好评率99%
00后直播软件
怎样用java做网站
vmware网络配置 双网卡
同一个ip不同端口
中国文化 知乎
卷积矩阵运算法则
sqlalchemy 原生sql
mysql 不重复的数据
淘宝销量提升
战舰世界大和主炮数据
赌博官网php源码
ubuntu 安装qt
nba百视通网络电视
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 吧台灯 led柜台灯 那种护眼灯好 护眼灯哪个好 学生护眼灯哪个好 护眼灯什么牌子好 6个纸杯做一个台灯方法 小学生用什么台灯好 可调节亮度的台灯 一次性纸杯制作台灯 用纸杯做手工小台灯 塑料瓶变废为宝做台灯 什么牌子的护眼台灯好 科技小制作简单又漂亮小台灯 台玻 台玻集团 台玻成都玻璃有限公司 台班 台班是什么意思 一个台班等于几个小时 一台班等于多少小时 吊车台班价格 2018吊车一个台班费多少 台球 台球规则 星期五台球 台球技巧 台球手势 台球桌尺寸 台球潘晓婷 台球姿势 台球杆法 台球怎么打 台球大师 台球加塞 台球杆 台球比赛 打台球 台球图片 台球教学 王小利台球

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里