Android Camera OMXCameraAdapter.cpp初始化分析

Android Camera OMXCameraAdapter.cpp初始化分析

这几天一直在研究android 的omx机制，我针对的android是4.0.3，主要是TI 的4430,4460的omx方式实现，这里还是简单的说一下为什么要研究这个文件
之前有一篇文章已经比较详细的说过了OMAP4系列芯片了，这里这个OMXCameraAdapter其实就是omap4 A9端的omx client，通过这个client与ducati端（也就是omap4的DSP端）的omx进行通信，可以把ducati端的这个omx简单理解为omx servicer，之前已经说了很多了andriod camera了，但是之前文章都是针对V4LCameraAdapter这个适配器进行的，这是大家都比较了解的，就是app通过V4L2这种方式与kernel camera driver实现交互，进而实现camera 的使用，包括数据回调等过程，但是这里的OMX方法完全颠覆了我之前的想法，开始在研究OMX的时候自己就是调用这个死胡同里了，一直在试图在OMX的实现中找到他到底是在哪么访问设备的，本来我是以后最终他还是通过V4L2这种方式，事实证明我错了，OMX是一种完全不同于V4L2 的访问camera的策略，他通过A9端的omx client和DSP端的omx通信，而且最终访问camera的方法是在DSP端omx server接到到A9端的omx client配置后按照指定方法实现camera 的控制的，这里ducati端到底是怎么处理的我暂时没有关注，暂时精力有限啊！
以上是我自己的见解，也许是完全错误的，待确认，这里只是总结我的分析过程
经过上面我的概述，自然A9端的这个OMXCameraAdapter对于我来说就是一切了，分析它是必经之路啊
现在就开始：
首先要知道在哪里实例化了这个类的对象，这个在之前已经说到过了，这个不在说明，重点看看他的initialize方法都干了些甚么？

1. /*--------------------Camera Adapter Class STARTS here-----------------------------*/
   
2. 
   
3. status_t OMXCameraAdapter::initialize(CameraProperties::Properties* caps)
   
4. {
   
5.     LOG_FUNCTION_NAME;
   
6. 
   
7.     char value[PROPERTY_VALUE_MAX];
   
8.     const char *mountOrientationString = NULL;
   
9. 
   
10.     property_get("debug.camera.showfps", value, "0");
    
11.     mDebugFps = atoi(value);
    
12.     property_get("debug.camera.framecounts", value, "0");
    
13.     mDebugFcs = atoi(value);
    
14. 
    
15. #ifdef CAMERAHAL_OMX_PROFILING
    
16. 
    
17.     property_get("debug.camera.profile", value, "0");
    
18.     mDebugProfile = atoi(value);
    
19. 
    
20. #endif
    
21. 
    
22.     TIMM_OSAL_ERRORTYPE osalError = OMX_ErrorNone;
    
23.     OMX_ERRORTYPE eError = OMX_ErrorNone;
    
24.     status_t ret = NO_ERROR;
    
25. 
    
26.     mLocalVersionParam.s.nVersionMajor = 0x1;
    
27.     mLocalVersionParam.s.nVersionMinor = 0x1;
    
28.     mLocalVersionParam.s.nRevision = 0x0 ;
    
29.     mLocalVersionParam.s.nStep = 0x0;
    
30. 
    
31.     mPending3Asettings = 0;//E3AsettingsAll;
    
32.     mPendingCaptureSettings = 0;
    
33.     mPendingPreviewSettings = 0;
    
34. 
    
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.         }
    
41. 
    
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;
    
57. 
    
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;
    
63. 
    
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);
    
70. 
    
71.     mComponentState = OMX_StateLoaded;
    
72. 
    
73.     CAMHAL_LOGVB("OMX_GetHandle -0x%x sensor_index = %lu", eError, mSensorIndex);
    
74.     initDccFileDataSave(&mCameraAdapterParameters.mHandleComp, mCameraAdapterParameters.mPrevPortIndex);
    
75. 
    
76.     eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp, OMX_CommandPortDisable, OMX_ALL,NULL);
77. 
    
78.     if(eError != OMX_ErrorNone) {
    
79.          CAMHAL_LOGEB("OMX_SendCommand(OMX_CommandPortDisable) -0x%x", eError);
    
80.     }
    
81.     GOTO_EXIT_IF((eError != OMX_ErrorNone), eError);
    
82. 
    
83.     // 4.Register for port enable event
    
84.     ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,
    
85.                                  OMX_EventCmdComplete,
    
86.                                  OMX_CommandPortEnable,
    
87.                                  mCameraAdapterParameters.mPrevPortIndex,
    
88.                                  mInitSem);
    
89.     if(ret != NO_ERROR) {
    
90.          CAMHAL_LOGEB("Error in registering for event %d", ret);
    
91.          goto EXIT;
    
92.     }
    
93. 
    
94.     // 5.Enable PREVIEW Port
    
95.     eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp,
    
96.                                  OMX_CommandPortEnable,
    
97.                                  mCameraAdapterParameters.mPrevPortIndex,
    
98.                                  NULL);
    
99.     if(eError != OMX_ErrorNone) {
    
100.         CAMHAL_LOGEB("OMX_SendCommand(OMX_CommandPortEnable) -0x%x", eError);
     
101.     }
     
102.     GOTO_EXIT_IF((eError!=OMX_ErrorNone), eError);
     
103. 
     
104.     // 6.Wait for the port enable event to occur
     
105.     ret = mInitSem.WaitTimeout(OMX_CMD_TIMEOUT);
     
106.     if ( NO_ERROR == ret ) {
     
107.          CAMHAL_LOGDA("-Port enable event arrived");
     
108.     } else {
     
109.          ret |= RemoveEvent(mCameraAdapterParameters.mHandleComp,
     
110.                             OMX_EventCmdComplete,
     
111.                             OMX_CommandPortEnable,
     
112.                             mCameraAdapterParameters.mPrevPortIndex,
     
113.                             NULL);
     
114.          CAMHAL_LOGEA("Timeout for enabling preview port expired!");
     
115.          goto EXIT;
     
116.      }
     
117. 
     
118.     // 7.Select the sensor
     
119.     OMX_CONFIG_SENSORSELECTTYPE sensorSelect;
     
120.     OMX_INIT_STRUCT_PTR (&sensorSelect, OMX_CONFIG_SENSORSELECTTYPE);
     
121.     sensorSelect.eSensor = (OMX_SENSORSELECT) mSensorIndex;
     
122.     eError = OMX_SetConfig(mCameraAdapterParameters.mHandleComp, ( OMX_INDEXTYPE ) OMX_TI_IndexConfigSensorSelect, &sensorSelect);
     
123.     if ( OMX_ErrorNone != eError ) {
     
124.         CAMHAL_LOGEB("Error while selecting the sensor index as %d - 0x%x", mSensorIndex, eError);
     
125.         return BAD_VALUE;
     
126.     } else {
     
127.         CAMHAL_LOGDB("Sensor %d selected successfully", mSensorIndex);
     
128.     }
     
129. 
     
130. #ifdef CAMERAHAL_DEBUG
     
131. 
     
132.     printComponentVersion(mCameraAdapterParameters.mHandleComp);
     
133. 
     
134. #endif
     
135.     // 8.初始化默认参数
     
136.     mBracketingEnabled = false;
     
137.     mZoomBracketingEnabled = false;
     
138.     mBracketingBuffersQueuedCount = 0;
     
139.     mBracketingRange = 1;
     
140.     mLastBracetingBufferIdx = 0;
     
141.     mBracketingBuffersQueued = NULL;
     
142.     mOMXStateSwitch = false;
     
143.     mBracketingSet = false;
     
144. #ifdef CAMERAHAL_USE_RAW_IMAGE_SAVING
     
145.     mRawCapture = false;
     
146.     mYuvCapture = false;
     
147. #endif
     
148. 
     
149.     mCaptureSignalled = false;
     
150.     mCaptureConfigured = false;
     
151.     mReprocConfigured = false;
     
152.     mRecording = false;
     
153.     mWaitingForSnapshot = false;
     
154.     mPictureFormatFromClient = NULL;
     
155. 
     
156.     mCapabilitiesOpMode = MODE_MAX;
     
157.     mCapMode = INITIAL_MODE;
     
158.     mIPP = IPP_NULL;
     
159.     mVstabEnabled = false;
     
160.     mVnfEnabled = false;
     
161.     mBurstFrames = 1;
     
162.     mBurstFramesAccum = 0;
     
163.     mCapturedFrames = 0;
     
164.     mFlushShotConfigQueue = false;
     
165.     mPictureQuality = 100;
     
166.     mCurrentZoomIdx = 0;
     
167.     mTargetZoomIdx = 0;
     
168.     mPreviousZoomIndx = 0;
     
169.     mReturnZoomStatus = false;
     
170.     mZoomInc = 1;
     
171.     mZoomParameterIdx = 0;
     
172.     mExposureBracketingValidEntries = 0;
     
173.     mZoomBracketingValidEntries = 0;
     
174.     mSensorOverclock = false;
     
175.     mAutoConv = OMX_TI_AutoConvergenceModeMax;
     
176.     mManualConv = 0;
     
177.     mDeviceOrientation = 0;
     
178.     mCapabilities = caps;
     
179.     mZoomUpdating = false;
     
180.     mZoomUpdate = false;
     
181.     mGBCE = BRIGHTNESS_OFF;
     
182.     mGLBCE = BRIGHTNESS_OFF;
     
183.     mParameters3A.ExposureLock = OMX_FALSE;
     
184.     mParameters3A.WhiteBalanceLock = OMX_FALSE;
     
185. 
     
186.     mEXIFData.mGPSData.mAltitudeValid = false;
     
187.     mEXIFData.mGPSData.mDatestampValid = false;
     
188.     mEXIFData.mGPSData.mLatValid = false;
     
189.     mEXIFData.mGPSData.mLongValid = false;
     
190.     mEXIFData.mGPSData.mMapDatumValid = false;
     
191.     mEXIFData.mGPSData.mProcMethodValid = false;
     
192.     mEXIFData.mGPSData.mVersionIdValid = false;
     
193.     mEXIFData.mGPSData.mTimeStampValid = false;
     
194.     mEXIFData.mModelValid = false;
     
195.     mEXIFData.mMakeValid = false;
     
196. 
     
197.     //update the mDeviceOrientation with the sensor mount orientation.
     
198.     //So that the face detect will work before onOrientationEvent()
     
199.     //get triggered.
     
200.     CAMHAL_ASSERT(mCapabilities);
     
201.     mountOrientationString = mCapabilities->get(CameraProperties::ORIENTATION_INDEX);
     
202.     CAMHAL_ASSERT(mountOrientationString);
     
203.     mDeviceOrientation = atoi(mountOrientationString);
     
204. 
     
205.     if (mSensorIndex != 2) {
     
206.         mCapabilities->setMode(MODE_HIGH_SPEED);
     
207.     }
     
208. 
     
209.     if (mCapabilities->get(CameraProperties::SUPPORTED_ZOOM_STAGES) != NULL) {
     
210.         mMaxZoomSupported = mCapabilities->getInt(CameraProperties::SUPPORTED_ZOOM_STAGES) + 1;
     
211.     } else {
     
212.         mMaxZoomSupported = 1;
     
213.     }
     
214. 
     
215.     // 9.initialize command handling thread
     
216.     if(mCommandHandler.get() == NULL)
     
217.         mCommandHandler = new CommandHandler(this);
     
218. 
     
219.     if ( NULL == mCommandHandler.get() )
     
220.     {
     
221.         CAMHAL_LOGEA("Couldn't create command handler");
     
222.         return NO_MEMORY;
     
223.     }
     
224. 
     
225.     ret = mCommandHandler->run("CallbackThread", PRIORITY_URGENT_DISPLAY);
     
226.     if ( ret != NO_ERROR )
     
227.     {
     
228.         if( ret == INVALID_OPERATION){
     
229.             CAMHAL_LOGDA("command handler thread already runnning!!");
     
230.             ret = NO_ERROR;
     
231.         } else {
     
232.             CAMHAL_LOGEA("Couldn't run command handlerthread");
     
233.             return ret;
     
234.         }
     
235.     }
     
236. 
     
237.     // 10.initialize omx callback handling thread
     
238.     if(mOMXCallbackHandler.get() == NULL)
     
239.         mOMXCallbackHandler = new OMXCallbackHandler(this);
     
240. 
     
241.     if ( NULL == mOMXCallbackHandler.get() )
     
242.     {
     
243.         CAMHAL_LOGEA("Couldn't create omx callback handler");
     
244.         return NO_MEMORY;
     
245.     }
     
246. 
     
247.     ret = mOMXCallbackHandler->run("OMXCallbackThread", PRIORITY_URGENT_DISPLAY);
     
248.     if ( ret != NO_ERROR )
     
249.     {
     
250.         if( ret == INVALID_OPERATION){
     
251.             CAMHAL_LOGDA("omx callback handler thread already runnning!!");
     
252.             ret = NO_ERROR;
     
253.         } else {
     
254.             CAMHAL_LOGEA("Couldn't run omx callback handler thread");
     
255.             return ret;
     
256.         }
     
257.     }
     
258. 
     
259.     OMX_INIT_STRUCT_PTR (&mRegionPriority, OMX_TI_CONFIG_3A_REGION_PRIORITY);
     
260.     OMX_INIT_STRUCT_PTR (&mFacePriority, OMX_TI_CONFIG_3A_FACE_PRIORITY);
     
261.     mRegionPriority.nPortIndex = OMX_ALL;
     
262.     mFacePriority.nPortIndex = OMX_ALL;
     
263. 
     
264.     //Setting this flag will that the first setParameter call will apply all 3A settings
     
265.     //and will not conditionally apply based on current values.
     
266.     mFirstTimeInit = true;
     
267. 
     
268.     //Flag to avoid calling setVFramerate() before OMX_SetParameter(OMX_IndexParamPortDefinition)
     
269.     //Ducati will return an error otherwise.
     
270.     mSetFormatDone = false;
     
271. 
     
272.     memset(mExposureBracketingValues, 0, EXP_BRACKET_RANGE*sizeof(int));
     
273.     memset(mZoomBracketingValues, 0, ZOOM_BRACKET_RANGE*sizeof(int));
     
274.     mMeasurementEnabled = false;
     
275.     mFaceDetectionRunning = false;
     
276.     mFaceDetectionPaused = false;
     
277.     mFDSwitchAlgoPriority = false;
     
278. 
     
279.     memset(&mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mImagePortIndex], 0, sizeof(OMXCameraPortParameters));
     
280.     memset(&mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mPrevPortIndex], 0, sizeof(OMXCameraPortParameters));
     
281.     memset(&mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mVideoPortIndex], 0, sizeof(OMXCameraPortParameters));
     
282.     memset(&mCameraAdapterParameters.mCameraPortParams[mCameraAdapterParameters.mVideoInPortIndex], 0, sizeof(OMXCameraPortParameters));
     
283. 
     
284.     // 11.initialize 3A defaults
     
285.     mParameters3A.Effect = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_EFFECT, EffLUT);
     
286.     mParameters3A.FlashMode = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_FLASH_MODE, FlashLUT);
     
287.     mParameters3A.SceneMode = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_SCENE_MODE, SceneLUT);
     
288.     mParameters3A.EVCompensation = atoi(OMXCameraAdapter::DEFAULT_EV_COMPENSATION);
     
289.     mParameters3A.Focus = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_FOCUS_MODE, FocusLUT);
     
290.     mParameters3A.ISO = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_ISO_MODE, IsoLUT);
     
291.     mParameters3A.Flicker = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_ANTIBANDING, FlickerLUT);
     
292.     mParameters3A.Brightness = atoi(OMXCameraAdapter::DEFAULT_BRIGHTNESS);
     
293.     mParameters3A.Saturation = atoi(OMXCameraAdapter::DEFAULT_SATURATION) - SATURATION_OFFSET;
     
294.     mParameters3A.Sharpness = atoi(OMXCameraAdapter::DEFAULT_SHARPNESS) - SHARPNESS_OFFSET;
     
295.     mParameters3A.Contrast = atoi(OMXCameraAdapter::DEFAULT_CONTRAST) - CONTRAST_OFFSET;
     
296.     mParameters3A.WhiteBallance = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_WB, WBalLUT);
     
297.     mParameters3A.Exposure = getLUTvalue_HALtoOMX(OMXCameraAdapter::DEFAULT_EXPOSURE_MODE, ExpLUT);
     
298.     mParameters3A.ExposureLock = OMX_FALSE;
     
299.     mParameters3A.FocusLock = OMX_FALSE;
     
300.     mParameters3A.WhiteBalanceLock = OMX_FALSE;
     
301. 
     
302.     mParameters3A.ManualExposure = 0;
     
303.     mParameters3A.ManualExposureRight = 0;
     
304.     mParameters3A.ManualGain = 0;
     
305.     mParameters3A.ManualGainRight = 0;
     
306. 
     
307.     mParameters3A.AlgoFixedGamma = OMX_TRUE;
     
308.     mParameters3A.AlgoNSF1 = OMX_TRUE;
     
309.     mParameters3A.AlgoNSF2 = OMX_TRUE;
     
310.     mParameters3A.AlgoSharpening = OMX_TRUE;
     
311.     mParameters3A.AlgoThreeLinColorMap = OMX_TRUE;
     
312.     mParameters3A.AlgoGIC = OMX_TRUE;
     
313. 
     
314.     LOG_FUNCTION_NAME_EXIT;
     
315.     return ErrorUtils::omxToAndroidError(eError);
     
316. 
     
317.     EXIT:
     
318. 
     
319.     CAMHAL_LOGDB("Exiting function %s because of ret %d eError=%x", __FUNCTION__, ret, eError);
     
320.     performCleanupAfterError();
     
321.     LOG_FUNCTION_NAME_EXIT;
     
322.     return ErrorUtils::omxToAndroidError(eError);
     
323. }

就是这里了，下面对上面的方法按步骤一一做分析

1.OMX_Init
从字面上就可以知道，要使用OMX这个方式，那就要为使用它做准备啊，初始化，但我们还是严谨点，说一说吧，

1. /** The OMX_Init method is used to initialize the OMX core. It shall be the
   
2.     first call made into OMX and it should only be executed one time without
   
3.     an interviening OMX_Deinit call. 
   
4.     
   
5.     The core should return from this call within 20 msec.
   
6. 
   
7.     @return OMX_ERRORTYPE
   
8.         If the command successfully executes, the return code will be
   
9.         OMX_ErrorNone. Otherwise the appropriate OMX error will be returned.
   
10.     @ingroup core
    
11.  */
    
12. OMX_API OMX_ERRORTYPE OMX_APIENTRY OMX_Init(void);

2.Initialize the callback handles
这里初始化callback handle，那么上面初始化了三个handle，这三个handle具体都实现什么用途呢？
当然一下不是我说的，是TI为方便大家理解，在andriod底层加入了很多很全的注释，一起看看吧

1. typedef struct OMX_CALLBACKTYPE
   
2. {
   
3.     /** The EventHandler method is used to notify the application when an
   
4.         event of interest occurs. Events are defined in the OMX_EVENTTYPE
   
5.         enumeration. Please see that enumeration for details of what will
   
6.         be returned for each type of event. Callbacks should not return
   
7.         an error to the component, so if an error occurs, the application 
   
8.         shall handle it internally. This is a blocking call.
   
9. 
   
10.         The application should return from this call within 5 msec to avoid
    
11.         blocking the component for an excessively long period of time.
    
12. 
    
13.         @param hComponent
    
14.             handle of the component to access. This is the component
    
15.             handle returned by the call to the GetHandle function.
    
16.         @param pAppData
    
17.             pointer to an application defined value that was provided in the 
    
18.             pAppData parameter to the OMX_GetHandle method for the component.
    
19.             This application defined value is provided so that the application 
    
20.             can have a component specific context when receiving the callback.
    
21.         @param eEvent
    
22.             Event that the component wants to notify the application about.
    
23.         @param nData1
    
24.             nData will be the OMX_ERRORTYPE for an error event and will be 
    
25.             an OMX_COMMANDTYPE for a command complete event and OMX_INDEXTYPE for a OMX_PortSettingsChanged event.
    
26.          @param nData2
    
27.             nData2 will hold further information related to the event. Can be OMX_STATETYPE for
    
28.             a OMX_CommandStateSet command or port index for a OMX_PortSettingsChanged event.
    
29.             Default value is 0 if not used. )
    
30.         @param pEventData
    
31.             Pointer to additional event-specific data (see spec for meaning).
    
32.       */
    
33. 
    
34.    OMX_ERRORTYPE (*EventHandler)(
    
35.         OMX_IN OMX_HANDLETYPE hComponent,
    
36.         OMX_IN OMX_PTR pAppData,
    
37.         OMX_IN OMX_EVENTTYPE eEvent,
    
38.         OMX_IN OMX_U32 nData1,
    
39.         OMX_IN OMX_U32 nData2,
    
40.         OMX_IN OMX_PTR pEventData);
    
41. 
    
42.     /** The EmptyBufferDone method is used to return emptied buffers from an
    
43.         input port back to the application for reuse. This is a blocking call 
    
44.         so the application should not attempt to refill the buffers during this
    
45.         call, but should queue them and refill them in another thread. There
    
46.         is no error return, so the application shall handle any errors generated
    
47.         internally. 
    
48.         
    
49.         The application should return from this call within 5 msec.
    
50.         
    
51.         @param hComponent
    
52.             handle of the component to access. This is the component
    
53.             handle returned by the call to the GetHandle function.
    
54.         @param pAppData
    
55.             pointer to an application defined value that was provided in the 
    
56.             pAppData parameter to the OMX_GetHandle method for the component.
    
57.             This application defined value is provided so that the application 
    
58.             can have a component specific context when receiving the callback.
    
59.         @param pBuffer
    
60.             pointer to an OMX_BUFFERHEADERTYPE structure allocated with UseBuffer
    
61.             or AllocateBuffer indicating the buffer that was emptied.
    
62.         @ingroup buf
    
63.      */
    
64.     OMX_ERRORTYPE (*EmptyBufferDone)(
    
65.         OMX_IN OMX_HANDLETYPE hComponent,
    
66.         OMX_IN OMX_PTR pAppData,
    
67.         OMX_IN OMX_BUFFERHEADERTYPE* pBuffer);
    
68. 
    
69.     /** The FillBufferDone method is used to return filled buffers from an
    
70.         output port back to the application for emptying and then reuse. 
    
71.         This is a blocking call so the application should not attempt to 
    
72.         empty the buffers during this call, but should queue the buffers 
    
73.         and empty them in another thread. There is no error return, so 
    
74.         the application shall handle any errors generated internally. The 
    
75.         application shall also update the buffer header to indicate the
    
76.         number of bytes placed into the buffer. 
    
77. 
    
78.         The application should return from this call within 5 msec.
    
79.         
    
80.         @param hComponent
    
81.             handle of the component to access. This is the component
    
82.             handle returned by the call to the GetHandle function.
    
83.         @param pAppData
    
84.             pointer to an application defined value that was provided in the 
    
85.             pAppData parameter to the OMX_GetHandle method for the component.
    
86.             This application defined value is provided so that the application 
    
87.             can have a component specific context when receiving the callback.
    
88.         @param pBuffer
    
89.             pointer to an OMX_BUFFERHEADERTYPE structure allocated with UseBuffer
    
90.             or AllocateBuffer indicating the buffer that was filled.
    
91.         @ingroup buf
    
92.      */
    
93.     OMX_ERRORTYPE (*FillBufferDone)(
    
94.         OMX_OUT OMX_HANDLETYPE hComponent,
    
95.         OMX_OUT OMX_PTR pAppData,
    
96.         OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer);
    
97. 
    
98. } OMX_CALLBACKTYPE;

EmptyBufferDone 方法用来实现从组件的输入端口获取到空的缓冲区返回给应用层使得可以重新被使用，这是一个阻塞型的调用，这个调用期间你不可以使用fillThisBuffer方法去fill这个缓冲区，你应该在另外一个线程中进行这个工作，这个回调方法不会提示error信息，所以需要用户端自己去分辨，并处理这些信息，保存错误信息；
EventHandler方法用来通知应用层一些应用层可能感兴趣的一些事件，事件分很多类型，已经用枚举方式定义在OMX_EVENTTYPE中，这个回调方法同样不会提示error信息，所以需要用户端自己去分辨，并处理这些信息，保存错误信息；
FillBufferDone方法用来实现从组件的输出端口获取到经过解码等很多操作的buffer，并且放回给应用层，应用层获取使用后，在通过emptyThisBuffer方法清空buffer再次利用，这个回调方法同样不会提示error信息，所以需要用户端自己去分辨，并处理这些信息，保存错误信息，这里应用层还有一件很重要的事情要做，应用程序要更新缓冲区header的位置，新数据加入，header后移；

3.Get the handle to the OMX Component

1. OMX_ERRORTYPE OMXCameraAdapter::OMXCameraGetHandle(OMX_HANDLETYPE *handle, OMX_PTR pAppData,
   
2.         const OMX_CALLBACKTYPE & callbacks)
   
3. {
   
4.     OMX_ERRORTYPE eError = OMX_ErrorUndefined;
   
5. 
   
6.     for ( int i = 0; i < 5; ++i ) {
   
7.         if ( i > 0 ) {
   
8.             // sleep for 100 ms before next attempt
   
9.             usleep(100000);
   
10.         }
    
11. 
    
12.         // setup key parameters to send to Ducati during init
    
13.         OMX_CALLBACKTYPE oCallbacks = callbacks;
    
14. 
    
15.         // get handle
    
16.         eError = OMX_GetHandle(handle, (OMX_STRING)"OMX.TI.DUCATI1.VIDEO.CAMERA", pAppData, &oCallbacks);
    
17.         if ( eError == OMX_ErrorNone ) {
    
18.             return OMX_ErrorNone;
    
19.         }
    
20. 
    
21.         CAMHAL_LOGEB("OMX_GetHandle() failed, error: 0x%x", eError);
    
22.     }
    
23. 
    
24.     *handle = 0;
    
25.     return eError;
    
26. }

这个传入上面初始化的callbacks，是为了获取到handle，这个handle对应一个组件，每个组件同样拥有自己的callbacks方法，所以这里不同的组件公用callbacks，看看这个OMX_GetHandle吧，因为有注释，可以更好理解啊，嘿嘿

1. /** The OMX_GetHandle method will locate the component specified by the
   
2.     component name given, load that component into memory and then invoke
   
3.     the component's methods to create an instance of the component. 
   
4.     
   
5.     The core should return from this call within 20 msec.
   
6.     
   
7.     @param [out] pHandle
   
8.         pointer to an OMX_HANDLETYPE pointer to be filled in by this method.
   
9.     @param [in] cComponentName
   
10.         pointer to a null terminated string with the component name. The
    
11.         names of the components are strings less than 127 bytes in length
    
12.         plus the trailing null for a maximum size of 128 bytes. An example 
    
13.         of a valid component name is "OMX.TI.AUDIO.DSP.MIXER\0". Names are 
    
14.         assigned by the vendor, but shall start with "OMX." and then have 
    
15.         the Vendor designation next.
    
16.     @param [in] pAppData
    
17.         pointer to an application defined value that will be returned
    
18.         during callbacks so that the application can identify the source
    
19.         of the callback.
    
20.     @param [in] pCallBacks
    
21.         pointer to a OMX_CALLBACKTYPE structure that will be passed to the
    
22.         component to initialize it with. 
    
23.     @return OMX_ERRORTYPE
    
24.         If the command successfully executes, the return code will be
    
25.         OMX_ErrorNone. Otherwise the appropriate OMX error will be returned.
    
26.     @ingroup core
    
27.  */
    
28. OMX_API OMX_ERRORTYPE OMX_APIENTRY OMX_GetHandle(
    
29.     OMX_OUT OMX_HANDLETYPE* pHandle, 
    
30.     OMX_IN OMX_STRING cComponentName,
    
31.     OMX_IN OMX_PTR pAppData,
    
32.     OMX_IN OMX_CALLBACKTYPE* pCallBacks);

这个方法会通过name获取到想要的组件，并且加载组件的内存，请求组件中定义的方法实例化组件

4.设置组件最初状态为OMX_StateLoaded状态，并disable所以command port
mComponentState = OMX_StateLoaded;
eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp, OMX_CommandPortDisable, OMX_ALL,NULL);
这里必须重点说说OMX_SendCommand这个方法

1. /** Send a command to the component. This call is a non-blocking call.
   
2.     The component should check the parameters and then queue the command
   
3.     to the component thread to be executed. The component thread shall 
   
4.     send the EventHandler() callback at the conclusion of the command. 
   
5.     This macro will go directly from the application to the component (via
   
6.     a core macro). The component will return from this call within 5 msec.
   
7.     
   
8.     When the command is "OMX_CommandStateSet" the component will queue a
   
9.     state transition to the new state idenfied in nParam.
   
10.     
    
11.     When the command is "OMX_CommandFlush", to flush a port's buffer queues,
    
12.     the command will force the component to return all buffers NOT CURRENTLY 
    
13.     BEING PROCESSED to the application, in the order in which the buffers 
    
14.     were received.
    
15.     
    
16.     When the command is "OMX_CommandPortDisable" or 
    
17.     "OMX_CommandPortEnable", the component's port (given by the value of
    
18.     nParam) will be stopped or restarted. 
    
19.     
    
20.     When the command "OMX_CommandMarkBuffer" is used to mark a buffer, the
    
21.     pCmdData will point to a OMX_MARKTYPE structure containing the component
    
22.     handle of the component to examine the buffer chain for the mark. nParam1
    
23.     contains the index of the port on which the buffer mark is applied.
    
24. 
    
25.     Specification text for more details. 
    
26.     
    
27.     @param [in] hComponent
    
28.         handle of component to execute the command
    
29.     @param [in] Cmd
    
30.         Command for the component to execute
    
31.     @param [in] nParam
    
32.         Parameter for the command to be executed. When Cmd has the value 
    
33.         OMX_CommandStateSet, value is a member of OMX_STATETYPE. When Cmd has 
    
34.         the value OMX_CommandFlush, value of nParam indicates which port(s) 
    
35.         to flush. -1 is used to flush all ports a single port index will 
    
36.         only flush that port. When Cmd has the value "OMX_CommandPortDisable"
    
37.         or "OMX_CommandPortEnable", the component's port is given by 
    
38.         the value of nParam. When Cmd has the value "OMX_CommandMarkBuffer"
    
39.         the components pot is given by the value of nParam.
    
40.     @param [in] pCmdData
    
41.         Parameter pointing to the OMX_MARKTYPE structure when Cmd has the value
    
42.         "OMX_CommandMarkBuffer". 
    
43.     @return OMX_ERRORTYPE
    
44.         If the command successfully executes, the return code will be
    
45.         OMX_ErrorNone. Otherwise the appropriate OMX error will be returned.
    
46.     @ingroup comp
    
47.  */
    
48. #define OMX_SendCommand( \
    
49.          hComponent, \
    
50.          Cmd, \
    
51.          nParam, \
    
52.          pCmdData) \
    
53.      ((OMX_COMPONENTTYPE*)hComponent)->SendCommand( \
    
54.          hComponent, \
    
55.          Cmd, \
    
56.          nParam, \
    
57.          pCmdData) /* Macro End */

通过这个方法给组件发送一个command，组件接收到command后会检查传入的参数并将这个command压入队列，待组件的处理线程处理，处理完成后会通过上面初始化的EventHandler通知应用层处理结果，最多不会超出5min，超过则超时报错，具体的command type上面注释中已经说明，简单说明一下吧
在上面参数中分为以下几种情况：
1.Cmd 为OMX_CommandStateSet
这种command用于组件状态之间的切换
这个第三个参数nParam代表参数类型是OMX_STATETYPE，是组件的状态参数

2.Cmd 为OMX_CommandFlush
这种command用于刷新组件缓冲区，不管是否缓冲区经过处理，缓冲区数据都会按照接收的顺序交给应用层
这个第三个参数nParam代表参数类型是组件的port，第四个参数pCmdData都为NULL

3.Cmd 为OMX_CommandPortDisable或者OMX_CommandPortEnable
这个情况下，第三个参数nParam代表要设置disable或enable的组件的port，OMX_ALL表示所有的组件，第四个参数pCmdData都为NULL

4.Cmd 为OMX_CommandMarkBuffer
这种command用于标记组件缓冲区
这个第三个参数nParam代表参数类型是组件的port，第四个参数的类型是OMX_MARKTYPE 结构

5.Register for port enable event
调用方式如下：
ret = RegisterForEvent(mCameraAdapterParameters.mHandleComp,//这个参数指定组件的handle
                                 OMX_EventCmdComplete,//这个参数是EventType
                                 OMX_CommandPortEnable,//nData1
                                 mCameraAdapterParameters.mPrevPortIndex,//nData2
                                 mInitSem);//这个参数是信号量，保证同步

1. status_t OMXCameraAdapter::RegisterForEvent(OMX_IN OMX_HANDLETYPE hComponent,
   
2.                                           OMX_IN OMX_EVENTTYPE eEvent,
   
3.                                           OMX_IN OMX_U32 nData1,
   
4.                                           OMX_IN OMX_U32 nData2,
   
5.                                           OMX_IN Semaphore &semaphore)
   
6. {
   
7.     status_t ret = NO_ERROR;
   
8.     ssize_t res;
   
9.     Mutex::Autolock lock(mEventLock);
   
10. 
    
11.     LOG_FUNCTION_NAME;
    
12.     TIUTILS::Message * msg = ( struct TIUTILS::Message * ) malloc(sizeof(struct TIUTILS::Message));
    
13.     if ( NULL != msg )
    
14.         {
    
15.         msg->command = ( unsigned int ) eEvent;
    
16.         msg->arg1 = ( void * ) nData1;
    
17.         msg->arg2 = ( void * ) nData2;
    
18.         msg->arg3 = ( void * ) &semaphore;
    
19.         msg->arg4 = ( void * ) hComponent;
    
20.         res = mEventSignalQ.add(msg);
    
21.         if ( NO_MEMORY == res )
    
22.             {
    
23.             CAMHAL_LOGEA("No ressources for inserting OMX events");
    
24.             free(msg);
    
25.             ret = -ENOMEM;
    
26.             }
    
27.         }
    
28. 
    
29.     LOG_FUNCTION_NAME_EXIT;
    
30. 
    
31.     return ret;
    
32. }

这里将传入的数据打包到message结构中，并且添加到mEventSignalQ队列中，这里先不说为什么，之后再说明

6.Enable PREVIEW Port
eError = OMX_SendCommand(mCameraAdapterParameters.mHandleComp,
                                 OMX_CommandPortEnable,
                                 mCameraAdapterParameters.mPrevPortIndex,
                                 NULL);
前面disable了所有组件，这里保证了只有previewPort enable了

7.Wait for the port enable event to occur
调用过程如下：
ret = mInitSem.WaitTimeout(OMX_CMD_TIMEOUT);
这里我自己的感觉还是比较难于理解，因为自己在看这部分一开始也没有吃透
所以这里是我眼中的重点，重点啊
首先上面第6步 sendcommand to 组件，那么组件就该给应用层以反馈，叫做callback也可以，这里是通过我们上面初始化的OMXCameraAdapterEventHandler这个callback来应答应用层的，我们就看看这个方法的具体实现方法

1. /* Application callback Functions */
   
2. /*========================================================*/
   
3. /* @ fn SampleTest_EventHandler :: Application callback */
   
4. /*========================================================*/
   
5. OMX_ERRORTYPE OMXCameraAdapter::OMXCameraAdapterEventHandler(OMX_IN OMX_HANDLETYPE hComponent,
   
6.                                           OMX_IN OMX_EVENTTYPE eEvent,
   
7.                                           OMX_IN OMX_U32 nData1,
   
8.                                           OMX_IN OMX_U32 nData2,
   
9.                                           OMX_IN OMX_PTR pEventData)
   
10. {
    
11. 
    
12.     LOG_FUNCTION_NAME;
    
13. 
    
14.     OMX_ERRORTYPE eError = OMX_ErrorNone;
    
15.     CAMHAL_LOGDB("+OMX_Event %x, %d %d", eEvent, (int)nData1, (int)nData2);
    
16. 
    
17.     switch (eEvent) {
    
18.         case OMX_EventCmdComplete:
    
19.             CAMHAL_LOGDB("+OMX_EventCmdComplete %d %d", (int)nData1, (int)nData2);
    
20. 
    
21.             if (OMX_CommandStateSet == nData1) {
    
22.                 mCameraAdapterParameters.mState = (OMX_STATETYPE) nData2;
    
23. 
    
24.             } else if (OMX_CommandFlush == nData1) {
    
25.                 CAMHAL_LOGDB("OMX_CommandFlush received for port %d", (int)nData2);
    
26. 
    
27.             } else if (OMX_CommandPortDisable == nData1) {
    
28.                 CAMHAL_LOGDB("OMX_CommandPortDisable received for port %d", (int)nData2);
    
29. 
    
30.             } else if (OMX_CommandPortEnable == nData1) {//我们发送的是OMX_CommandPortEnable命令，所以这了nData1就是command type
    
31.                 CAMHAL_LOGDB("OMX_CommandPortEnable received for port %d", (int)nData2);
    
32. 
    
33.             } else if (OMX_CommandMarkBuffer == nData1) {
    
34.                 ///This is not used currently
    
35.             }
    
36. 
    
37.             CAMHAL_LOGDA("-OMX_EventCmdComplete");
    
38.         break;
    
39. 
    
40.         case OMX_EventIndexSettingChanged:
    
41.             CAMHAL_LOGDB("OMX_EventIndexSettingChanged event received data1 0x%x, data2 0x%x",
    
42.                             ( unsigned int ) nData1, ( unsigned int ) nData2);
    
43.             break;
    
44. 
    
45.         case OMX_EventError:
    
46.             CAMHAL_LOGDB("OMX interface failed to execute OMX command %d", (int)nData1);
    
47.             CAMHAL_LOGDA("See OMX_INDEXTYPE for reference");
    
48.             if ( NULL != mErrorNotifier && ( ( OMX_U32 ) OMX_ErrorHardware == nData1 ) && mComponentState != OMX_StateInvalid)
    
49.               {
    
50.                 CAMHAL_LOGEA("***Got Fatal Error Notification***\n");
    
51.                 mComponentState = OMX_StateInvalid;
    
52.                 /*
    
53.                 Remove any unhandled events and
    
54.                 unblock any waiting semaphores
    
55.                 */
    
56.                 if ( !mEventSignalQ.isEmpty() )
    
57.                   {
    
58.                     for (unsigned int i = 0 ; i < mEventSignalQ.size(); i++ )
    
59.                       {
    
60.                         CAMHAL_LOGEB("***Removing %d EVENTS***** \n", mEventSignalQ.size());
    
61.                         //remove from queue and free msg
    
62.                         TIUTILS::Message *msg = mEventSignalQ.itemAt(i);
    
63.                         if ( NULL != msg )
    
64.                           {
    
65.                             Semaphore *sem = (Semaphore*) msg->arg3;
    
66.                             if ( sem )
    
67.                               {
    
68.                                 sem->Signal();
    
69.                               }
    
70.                             free(msg);
    
71.                           }
    
72.                       }
    
73.                     mEventSignalQ.clear();
    
74.                   }
    
75.                 ///Report Error to App
    
76.                 mErrorNotifier->errorNotify(CAMERA_ERROR_FATAL);
    
77.               }
    
78.             break;
    
79. 
    
80.         case OMX_EventMark:
    
81.         break;
    
82. 
    
83.         case OMX_EventPortSettingsChanged:
    
84.         break;
    
85. 
    
86.         case OMX_EventBufferFlag:
    
87.         break;
    
88. 
    
89.         case OMX_EventResourcesAcquired:
    
90.         break;
    
91. 
    
92.         case OMX_EventComponentResumed:
    
93.         break;
    
94. 
    
95.         case OMX_EventDynamicResourcesAvailable:
    
96.         break;
    
97. 
    
98.         case OMX_EventPortFormatDetected:
    
99.         break;
    
100. 
     
101.         default:
     
102.         break;
     
103.     }
     
104. 
     
105.     ///Signal to the thread(s) waiting that the event has occured
     
106.     SignalEvent(hComponent, eEvent, nData1, nData2, pEventData);//这里才是重点
     
107. 
     
108.    LOG_FUNCTION_NAME_EXIT;
     
109.    return eError;
     
110. 
     
111.     EXIT:
     
112. 
     
113.     CAMHAL_LOGEB("Exiting function %s because of eError=%x", __FUNCTION__, eError);
     
114.     LOG_FUNCTION_NAME_EXIT;
     
115.     return eError;
     
116. }

我们接着看看SignalEvent的实现

1. OMX_ERRORTYPE OMXCameraAdapter::SignalEvent(OMX_IN OMX_HANDLETYPE hComponent,
   
2.                                           OMX_IN OMX_EVENTTYPE eEvent,
   
3.                                           OMX_IN OMX_U32 nData1,
   
4.                                           OMX_IN OMX_U32 nData2,
   
5.                                           OMX_IN OMX_PTR pEventData)
   
6. {
   
7.     Mutex::Autolock lock(mEventLock);
   
8.     TIUTILS::Message *msg;
   
9.     bool eventSignalled = false;
   
10. 
    
11.     LOG_FUNCTION_NAME;
    
12. 
    
13.     if ( !mEventSignalQ.isEmpty() )
    
14.         {
    
15.         CAMHAL_LOGDA("Event queue not empty");
    
16. 
    
17.         for ( unsigned int i = 0 ; i < mEventSignalQ.size() ; i++ )
    
18.             {
    
19.             msg = mEventSignalQ.itemAt(i);
    
20.             if ( NULL != msg )
    
21.                 {
    
22.                 if( ( msg->command != 0 || msg->command == ( unsigned int ) ( eEvent ) )
    
23.                     && ( !msg->arg1 || ( OMX_U32 ) msg->arg1 == nData1 )
    
24.                     && ( !msg->arg2 || ( OMX_U32 ) msg->arg2 == nData2 )
    
25.                     && msg->arg3)
    
26.                     {
    
27.                     Semaphore *sem = (Semaphore*) msg->arg3;
    
28.                     CAMHAL_LOGDA("Event matched, signalling sem");
    
29.                     mEventSignalQ.removeAt(i);
    
30.                     //Signal the semaphore provided
    
31.                     sem->Signal();
    
32.                     free(msg);
    
33.                     break;
    
34.                     }
    
35.                 }
    
36.             }
    
37.         }
    
38.     else
    
39.         {
    
40.         CAMHAL_LOGDA("Event queue empty!!!");
    
41.         }
    
42. 
    
43.     // Special handling for any unregistered events
    
44.     if (!eventSignalled) {
    
45.         // Handling for focus callback
    
46.         if ((nData2 == OMX_IndexConfigCommonFocusStatus) &&
    
47.             (eEvent == (OMX_EVENTTYPE) OMX_EventIndexSettingChanged)) {
    
48.                 TIUTILS::Message msg;
    
49.                 msg.command = OMXCallbackHandler::CAMERA_FOCUS_STATUS;
    
50.                 msg.arg1 = NULL;
    
51.                 msg.arg2 = NULL;
    
52.                 mOMXCallbackHandler->put(&msg);
    
53.         }
    
54.     }
    
55. 
    
56.     LOG_FUNCTION_NAME_EXIT;
    
57. 
    
58.     return OMX_ErrorNone;
    
59. }

这里我们只关注上面的实现，至于下面handle focus callback这里咱不做说明，以后可能会再次碰到
我们看看上面的语句到底做了什么，检测到mEventSignalQ这个消息队列中有消息，而这里在第6步中不是刚刚往这个消息队列中添加了一个消息嘛！看来他们有点暧昧，接着看，进行了遍历查找的操作，那么找的到底是什么呢？上面的判断条件很明确，不同的一点马虎，看看这个消息队列中是是否有和我从组件发来的消息一致的消息，找到了，那就说明消息处理完了，组件成功应答给应用层了，那么就得到了那个信号量，并且发送一个信号给wait方法，wait方法接到信号立即返回，否则一直等待直到超时，超时返回非零值，否则返回零，程序中如果wait超时，调用RemoveEvent方法

1. OMX_ERRORTYPE OMXCameraAdapter::RemoveEvent(OMX_IN OMX_HANDLETYPE hComponent,
   
2.                                             OMX_IN OMX_EVENTTYPE eEvent,
   
3.                                             OMX_IN OMX_U32 nData1,
   
4.                                             OMX_IN OMX_U32 nData2,
   
5.                                             OMX_IN OMX_PTR pEventData)
   
6. {
   
7.   Mutex::Autolock lock(mEventLock);
   
8.   TIUTILS::Message *msg;
   
9.   LOG_FUNCTION_NAME;
   
10. 
    
11.   if ( !mEventSignalQ.isEmpty() )
    
12.     {
    
13.       CAMHAL_LOGDA("Event queue not empty");
    
14. 
    
15.       for ( unsigned int i = 0 ; i < mEventSignalQ.size() ; i++ )
    
16.         {
    
17.           msg = mEventSignalQ.itemAt(i);
    
18.           if ( NULL != msg )
    
19.             {
    
20.               if( ( msg->command != 0 || msg->command == ( unsigned int ) ( eEvent ) )
    
21.                   && ( !msg->arg1 || ( OMX_U32 ) msg->arg1 == nData1 )
    
22.                   && ( !msg->arg2 || ( OMX_U32 ) msg->arg2 == nData2 )
    
23.                   && msg->arg3)
    
24.                 {
    
25.                   Semaphore *sem = (Semaphore*) msg->arg3;
    
26.                   CAMHAL_LOGDA("Event matched, signalling sem");
    
27.                   mEventSignalQ.removeAt(i);
    
28.                   free(msg);
    
29.                   break;
    
30.                 }
    
31.             }
    
32.         }
    
33.     }
    
34.   else
    
35.     {
    
36.       CAMHAL_LOGEA("Event queue empty!!!");
    
37.     }
    
38.   LOG_FUNCTION_NAME_EXIT;
    
39. 
    
40.   return OMX_ErrorNone;
    
41. }

这个方法检查mEventSignalQ如果中有成员消息，那么就清除掉mEventSignalQ其中的所有消息，这个是错误处理，以后还是会接着使用mEventSignalQ这个消息队列的，这里已经说的很清楚了，为什么在OMX_SendCommand之前要RegisterForEvent，就是为了要判断组件有没有按照我发送给他的命令干活，处理完后给我应答了，我就认为他乖乖的按照我的要求做了事情，这里那叫一个重要，因为后面还会有很多这个机制的使用
这里有一个地方我还是要提及一下，那就是组件回馈的enent类型，直接贴在这里

1. /** @ingroup comp */
   
2. typedef enum OMX_EVENTTYPE
   
3. {
   
4.     OMX_EventCmdComplete, /**< component has sucessfully completed a command */
   
5.     OMX_EventError, /**< component has detected an error condition */
   
6.     OMX_EventMark, /**< component has detected a buffer mark */
   
7.     OMX_EventPortSettingsChanged, /**< component is reported a port settings change */
   
8.     OMX_EventBufferFlag, /**< component has detected an EOS */ 
   
9.     OMX_EventResourcesAcquired, /**< component has been granted resources and is
   
10.                                        automatically starting the state change from
    
11.                                        OMX_StateWaitForResources to OMX_StateIdle. */
    
12.    OMX_EventComponentResumed, /**< Component resumed due to reacquisition of resources */
    
13.    OMX_EventDynamicResourcesAvailable, /**< Component has acquired previously unavailable dynamic resources */
    
14.    OMX_EventPortFormatDetected, /**< Component has detected a supported format. */
    
15.    OMX_EventKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
    
16.    OMX_EventVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
    
17.    OMX_EventMax = 0x7FFFFFFF
    
18. } OMX_EVENTTYPE;

8.Select the sensor
这里我们首先看看OMX_CONFIG_SENSORSELECTTYPE这个结构
定义在以下目录：hardware\ti\omap4xxx\domx\omx_core\inc\OMX_TI_IVCommon.h

1.  /*
   
2.  * Sensor Select
   
3.  */
   
4. typedef struct OMX_CONFIG_SENSORSELECTTYPE {
   
5. OMX_U32 nSize; /**< Size of the structure in bytes */
   
6. OMX_VERSIONTYPE nVersion; /**< OMX specification version info */
   
7. OMX_U32 nPortIndex; /**< Port that this struct applies to */
   
8. OMX_SENSORSELECT eSensor; /**< sensor select */
   
9. } OMX_CONFIG_SENSORSELECTTYPE;

接着来看下面这个方法的实现
OMX_INIT_STRUCT_PTR (&sensorSelect, OMX_CONFIG_SENSORSELECTTYPE);

1. #define OMX_INIT_STRUCT_PTR(_s_, _name_) \
   
2.     memset((_s_), 0x0, sizeof(_name_)); \
   
3.     (_s_)->nSize = sizeof(_name_); \
   
4.     (_s_)->nVersion.s.nVersionMajor = 0x1; \
   
5.     (_s_)->nVersion.s.nVersionMinor = 0x1; \
   
6.     (_s_)->nVersion.s.nRevision = 0x0; \
   
7.     (_s_)->nVersion.s.nStep = 0x0

这个方法只是对sensorSelect这个结构进行初始化和填充而已，传入OMX_CONFIG_SENSORSELECTTYPE结构体只是为了获取他的大小，挺大财小用不是吗？？嘿嘿
最后调用OMX_SetConfig（）这个方法

1. /** The OMX_SetConfig macro will send one of the configuration 
   
2.     structures to a component. Each structure shall be sent one at a time,
   
3.     each in a separate invocation of the macro. This macro can be invoked 
   
4.     anytime after the component has been loaded. The application shall 
   
5.     allocate the correct structure and shall fill in the structure size 
   
6.     and version information (as well as the actual data) before invoking 
   
7.     this macro. The application is free to dispose of this structure after 
   
8.     the call as the component is required to copy any data it shall retain. 
   
9.     This is a blocking call. 
   
10.     
    
11.     The component should return from this call within 5 msec.
    
12.     
    
13.     @param [in] hComponent
    
14.         Handle of the component to be accessed. This is the component
    
15.         handle returned by the call to the OMX_GetHandle function.
    
16.     @param [in] nConfigIndex
    
17.         Index of the structure to be sent. This value is from the
    
18.         OMX_INDEXTYPE enumeration above.
    
19.     @param [in] pComponentConfigStructure
    
20.         pointer to application allocated structure to be used for
    
21.         initialization by the component.
    
22.     @return OMX_ERRORTYPE
    
23.         If the command successfully executes, the return code will be
    
24.         OMX_ErrorNone. Otherwise the appropriate OMX error will be returned.
    
25.     @ingroup comp
    
26.  */
    
27. #define OMX_SetConfig( \
    
28.         hComponent, \
    
29.         nConfigIndex, \
    
30.         pComponentConfigStructure) \
    
31.     ((OMX_COMPONENTTYPE*)hComponent)->SetConfig( \
    
32.         hComponent, \
    
33.         nConfigIndex, \
    
34.         pComponentConfigStructure) /* Macro End */

9.参数初始化
其中最重要的是initialize方法引入的参数传递给了mCapabilities 
mCapabilities = caps;
并且通过mCapabilities->get（）方法获得相应的参数初始化

10.initialize command handling thread
这里只是创建了一个CommandHandler线程，并且启动了这个线程，我们重点看看这个线程都干了些甚么

1. bool OMXCameraAdapter::CommandHandler::Handler()
   
2. {
   
3.     TIUTILS::Message msg;
   
4.     volatile int forever = 1;
   
5.     status_t stat;
   
6.     ErrorNotifier *errorNotify = NULL;
   
7. 
   
8.     LOG_FUNCTION_NAME;
   
9. 
   
10.     while ( forever )
    
11.         {
    
12.         stat = NO_ERROR;
    
13.         CAMHAL_LOGDA("Handler: waiting for messsage...");
    
14.         TIUTILS::MessageQueue::waitForMsg(&mCommandMsgQ, NULL, NULL, -1);
    
15.         {
    
16.         Mutex::Autolock lock(mLock);
    
17.         mCommandMsgQ.get(&msg);
    
18.         }
    
19.         CAMHAL_LOGDB("msg.command = %d", msg.command);
    
20.         switch ( msg.command ) {
    
21.             case CommandHandler::CAMERA_START_IMAGE_CAPTURE:
    
22.             {
    
23.                 OMXCameraAdapter::CachedCaptureParameters* cap_params =
    
24.                         static_cast<OMXCameraAdapter::CachedCaptureParameters*>(msg.arg2);
    
25.                 stat = mCameraAdapter->startImageCapture(false, cap_params);
    
26.                 delete cap_params;
    
27.                 break;
    
28.             }
    
29.             case CommandHandler::CAMERA_PERFORM_AUTOFOCUS:
    
30.             {
    
31.                 stat = mCameraAdapter->doAutoFocus();
    
32.                 break;
    
33.             }
    
34.             case CommandHandler::COMMAND_EXIT:
    
35.             {
    
36.                 CAMHAL_LOGDA("Exiting command handler");
    
37.                 forever = 0;
    
38.                 break;
    
39.             }
    
40.             case CommandHandler::CAMERA_SWITCH_TO_EXECUTING:
    
41.             {
    
42.                 stat = mCameraAdapter->doSwitchToExecuting();
    
43.                 break;
    
44.             }
    
45.             case CommandHandler::CAMERA_START_REPROCESS:
    
46.             {
    
47.                 OMXCameraAdapter::CachedCaptureParameters* cap_params =
    
48.                         static_cast<OMXCameraAdapter::CachedCaptureParameters*>(msg.arg2);
    
49.                 stat = mCameraAdapter->startReprocess();
    
50.                 stat = mCameraAdapter->startImageCapture(false, cap_params);
    
51.                 delete cap_params;
    
52.                 break;
    
53.             }
    
54.         }
    
55. 
    
56.         }
    
57. 
    
58.     LOG_FUNCTION_NAME_EXIT;
    
59. 
    
60.     return false;
    
61. }

11.initialize omx callback handling thread
这里和上面很类似，创建一个OMXCallbackHandler线程，并启动这个线程，同样看看这个线程都干了些甚么

1. bool OMXCameraAdapter::OMXCallbackHandler::Handler()
   
2. {
   
3.     TIUTILS::Message msg;
   
4.     volatile int forever = 1;
   
5.     status_t ret = NO_ERROR;
   
6. 
   
7.     LOG_FUNCTION_NAME;
   
8. 
   
9.     while(forever){
   
10.         TIUTILS::MessageQueue::waitForMsg(&mCommandMsgQ, NULL, NULL, -1);
    
11.         {
    
12.         Mutex::Autolock lock(mLock);
    
13.         mCommandMsgQ.get(&msg);
    
14.         mIsProcessed = false;
    
15.         }
    
16. 
    
17.         switch ( msg.command ) {
    
18.             case OMXCallbackHandler::CAMERA_FILL_BUFFER_DONE:
    
19.             {
    
20.                 ret = mCameraAdapter->OMXCameraAdapterFillBufferDone(( OMX_HANDLETYPE ) msg.arg1,
    
21.                                                                      ( OMX_BUFFERHEADERTYPE *) msg.arg2);
    
22.                 break;
    
23.             }
    
24.             case OMXCallbackHandler::CAMERA_FOCUS_STATUS:
    
25.             {
    
26.                 mCameraAdapter->handleFocusCallback();
    
27.                 break;
    
28.             }
    
29.             case CommandHandler::COMMAND_EXIT:
    
30.             {
    
31.                 CAMHAL_LOGDA("Exiting OMX callback handler");
    
32.                 forever = 0;
    
33.                 break;
    
34.             }
    
35.         }
    
36. 
    
37.         {
    
38.             android::AutoMutex locker(mLock);
    
39.             CAMHAL_UNUSED(locker);
    
40. 
    
41.             mIsProcessed = mCommandMsgQ.isEmpty();
    
42.             if ( mIsProcessed )
    
43.                 mCondition.signal();
    
44.         }
    
45.     }
    
46. 
    
47.     // force the condition to wake
    
48.     {
    
49.         android::AutoMutex locker(mLock);
    
50.         CAMHAL_UNUSED(locker);
    
51. 
    
52.         mIsProcessed = true;
    
53.         mCondition.signal();
    
54.     }
    
55. 
    
56.     LOG_FUNCTION_NAME_EXIT;
    
57.     return false;
    
58. }

12.initialize 3A defaults
这里暂不做说明，都是对很多参数的基本初始化
到这里为止，OMXCameraAdapter的初始化就结束了
待续。。。。。