Android Camera 数据流

Camera应用部分：

Packages/apps/camera/src/com/android/camera/camera.java

Camera本地框架：

frameworks/base/core/java/android/hardware/camera.java

Camera服务部分：

frameworks/base/services/camera/libcameraservice，这部分需要camera的硬件抽象层来实现上述的本地框架，会被编译成库Libcameraservice.so

Camera硬件接口层

frameworks/base/include/camera/CameraHardwareInterface.h

Camera HAL部分：

Devices/Samsung/proprietary/libcamera/
 

篇幅主要以take picture为例

点击(此处)折叠或打开

1. 首先从上层讲解下来
   
2. Packages/apps/camera/src/com/android/camera/camera.java
   
3. private void capture() {
   
4.             mCaptureOnlyData = null;
   
5.             // See android.hardware.Camera.Parameters.setRotation for
   
6.             mParameters.setRotation(rotation);
   
7.           …….
   
8.            mCameraDevice.setParameters(mParameters);
   
9.                 //app 应用注册takepicture回调函数
   
10.             mCameraDevice.takePicture(mShutterCallback, mRawPictureCallback,
    
11.                     mPostViewPictureCallback, new JpegPictureCallback(loc));
    
12.             mPreviewing = false;
    
13.         }
    
14. 下面是关于四个回调函数的实现
    
15. private final class ShutterCallback
    
16.             implements android.hardware.Camera.ShutterCallback {
    
17.         public void onShutter() {
    
18.             mShutterCallbackTime = System.currentTimeMillis();
    
19.             mShutterLag = mShutterCallbackTime - mCaptureStartTime;
    
20.             Log.v(TAG, "mShutterLag = " + mShutterLag + "ms");
    
21.             clearFocusState();
    
22.         }
    
23. }
    
24. 
    
25.   private final class RawPictureCallback implements PictureCallback {
    
26.         public void onPictureTaken(
    
27.                 byte [] rawData, android.hardware.Camera camera) {
    
28.             mRawPictureCallbackTime = System.currentTimeMillis();
    
29.             Log.v(TAG, "mShutterToRawCallbackTime = "
    
30.                     + (mRawPictureCallbackTime - mShutterCallbackTime) + "ms");
    
31.         }
    
32.     }
    
33. 
    
34.     private final class PostViewPictureCallback implements PictureCallback {
35.         public void onPictureTaken(
    
36.                 byte [] data, android.hardware.Camera camera) {
    
37.             mPostViewPictureCallbackTime = System.currentTimeMillis();
    
38.             Log.v(TAG, "mShutterToPostViewCallbackTime = "
    
39.                     + (mPostViewPictureCallbackTime - mShutterCallbackTime)
    
40.                     + "ms");
    
41.         }
    
42.     }
    
43.     private final class JpegPictureCallback implements PictureCallback {
    
44.         Location mLocation;
    
45. 
    
46.         public void onPictureTaken(
    
47.                 final byte [] jpegData, final android.hardware.Camera camera) {
    
48.             if (mPausing) {
    
49.                 return;
    
50.             }
    
51.             mJpegPictureCallbackTime = System.currentTimeMillis();
    
52.    
    
53.            …………………..
    
54.                 //这个函数等下做详解
    
55.             mImageCapture.storeImage(jpegData, camera, mLocation);
    
56.         }
    
57.     }
    
58. 2、上层注册好回调函数之后frameworks/base/core/java/android/hardware/camera.java注册回调函数
    
59.   public final void takePicture(ShutterCallback shutter, PictureCallback raw,
    
60.             PictureCallback postview, PictureCallback jpeg) {
    
61.         mShutterCallback = shutter;
    
62.         mRawImageCallback = raw;
    
63.         mPostviewCallback = postview;
    
64.         mJpegCallback = jpeg;
    
65.      native_takePicture();
    
66.     }
    
67. 
    
68. frameworks/base/services/camera/libcameraservice
    
69. // take a picture - image is returned in callback
    
70. status_t CameraService::Client::takePicture() {
    
71.     LOG1("takePicture (pid %d)", getCallingPid());
72.     Mutex::Autolock lock(mLock);
    
73.     status_t result = checkPidAndHardware();
    
74.     if (result != NO_ERROR) return result;
    
75. 
    
76.         //用于判断指定的msg所对应的callback是否可以回调
    
77.     enableMsgType(CAMERA_MSG_SHUTTER |
    
78.                   CAMERA_MSG_POSTVIEW_FRAME |
    
79.                   CAMERA_MSG_RAW_IMAGE |
    
80.                   CAMERA_MSG_COMPRESSED_IMAGE);
    
81. 
    
82.     return mHardware->takePicture();//从这里就进入hal实现了，即上层提供操作设备驱动的接口
    
83. }
    
84. 3、HAL层的实现，接口被定义在cameraHardwareInterface.h文件中，所以hal层要做的就是实现其接口
    
85. 其实写到这里，还是有很多不了解，如service中stub的概念，IPC的机制如何实现，功底还是太浅了，有空专门研究下这块
    
86. 下面就仔细看下hal如何实现takepicture操作，同时向上层传递data
    
87. status_t CameraHardwareSec::takePicture()
    
88. {
    
89.       stopPreview();
    
90.     Mutex::Autolock lock(mStateLock);
    
91.     if (mCaptureInProgress) {
    
92.         LOGE("%s : capture already in progress", __func__);
    
93.         return INVALID_OPERATION;
    
94.     }
    
95.     //启动PictureThread线程
    
96.     if (mPictureThread->run("CameraPictureThread", PRIORITY_DEFAULT) != NO_ERROR) {
    
97.         LOGE("%s : couldn't run picture thread", __func__);
    
98.         return INVALID_OPERATION;
    
99.     }
    
100.     mCaptureInProgress = true;
     
101.     return NO_ERROR;
     
102. }
     
103. int CameraHardwareSec::pictureThread()
     
104. {
     
105.     mRawHeap = new MemoryHeapBase(picture_size);
     
106.     if (mRawHeap->getHeapID() < 0) {
     
107.         LOGE("ERR(%s): Raw heap creation fail", __func__);
     
108.         mRawHeap.clear();
     
109.         return UNKNOWN_ERROR;
     
110.     }
     
111. 
     
112.     sp<MemoryHeapBase> JpegHeap;
     
113.     sp<MemoryHeapBase> PostviewHeap;
     
114.     sp<MemoryHeapBase> ThumbnailHeap;
     
115.     sp<MemoryBase> buffer = new MemoryBase(mRawHeap, 0, picture_size + 8);
     
116. 
     
117. //主要是将raw data照片原始数据通过encode成jpeg的格式
     
118.     if ((mMsgEnabled & CAMERA_MSG_RAW_IMAGE)&&(mSecCamera->getJpegStreamPossible() != true)) {
     
119.         LOG_TIME_DEFINE(1)
     
120.         LOG_TIME_START(1)
     
121.      JpegHeap = new MemoryHeapBase(jpeg_heap_size);
     
122.          PostviewHeap = new MemoryHeapBase(picture_size);
     
123.         ThumbnailHeap = new MemoryHeapBase(thumb_size);    
     
124.         // Modified the shutter sound timing for Jpeg capture
     
125.         mSecCamera->startSnapshot();
     
126.         if (mMsgEnabled & CAMERA_MSG_SHUTTER) {
     
127.             //回调shuttcallback的接口
     
128.             mNotifyCb(CAMERA_MSG_SHUTTER, 0, 0, mCallbackCookie);
     
129.         }
     
130.         if(mSecCamera->getJpegStreamPossible() != true){
     
131.             if (mSecCamera->getSnapshotAndJpeg((unsigned char*)PostviewHeap->base(),
     
132.                     (unsigned char*)JpegHeap->base(), &jpeg_size) < 0) {
     
133.                 LOGE("ERR(%s):Fail on SecCamera->getSnapshotAndJpeg()", __func__);
     
134.                 mStateLock.lock();
     
135.                 mCaptureInProgress = false;
     
136.                 mStateLock.unlock();
     
137.                 return UNKNOWN_ERROR;
     
138.             }
     
139.         }
     
140.     }
     
141. 
     
142.     int JpegImageSize = 10000, JpegExifSize;
     
143.     bool isLSISensor = false;
     
144.      JpegImageSize = static_cast<int>(jpeg_size);
     
145.     CropScaleYUY2((char *)PostviewHeap->base(), picture_width, picture_height, 0, 0,
     
146.                   (char *)ThumbnailHeap->base(), thumb_width, thumb_height);
     
147.     memcpy(mRawHeap->base(),PostviewHeap->base(), picture_size);
     
148. 
     
149. }
     
150.     memcpy(static_cast<unsigned char*>(mPreviewHeap->base()) + offset + (previewWidth*previewHeight * 3 / 2),
     
151.             overlay_header, mSizeOfADDRS);
     
152. 
     
153.     ret = mOverlay->queueBuffer((void*)(static_cast<unsigned char *>(mPreviewHeap->base()) + offset +
     
154.                                 (previewWidth * previewHeight * 3 / 2)));
     
155.     if ((mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE) &&(mSecCamera->getJpegStreamPossible() != true)) {
     
156.         sp<MemoryHeapBase> ExifHeap = new MemoryHeapBase(EXIF_FILE_SIZE + picture_size);
     
157.      if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE)    
     
158.          mDataCb(CAMERA_MSG_RAW_IMAGE, buffer, mCallbackCookie);
     
159.             JpegExifSize = mSecCamera->getExif((unsigned char *)ExifHeap->base(),
     
160.                     (unsigned char *)ThumbnailHeap->base());
     
161. 
     
162.         LOGW("JpegExifSize=%d", JpegExifSize);
     
163.             unsigned char *ExifStart = (unsigned char *)JpegHeap->base() + 2;
     
164.             unsigned char *ImageStart = ExifStart + JpegExifSize;
     
165. 
     
166.             memmove(ImageStart, ExifStart, JpegImageSize - 2);
     
167.             memcpy(ExifStart, ExifHeap->base(), JpegExifSize);
     
168.         sp<MemoryBase> mem = new MemoryBase(JpegHeap, 0, JpegImageSize + JpegExifSize);
     
169.         //压缩格式照片消息
     
170.         mDataCb(CAMERA_MSG_COMPRESSED_IMAGE, mem, mCallbackCookie);
     
171.     }
     
172. }
     
173. 
     
174. 现在我们来看下在hal定义的三个回调函数
     
175. typedef void (*notify_callback)(int32_t msgType, //用于处理一些通知的消息，如快门
     
176.                                 int32_t ext1,
     
177.                                 int32_t ext2,
     
178.                                 void* user);
     
179. 
     
180. typedef void (*data_callback)(int32_t msgType, // 返回通过camera得到的raw data
     
181.                               const sp<IMemory>& dataPtr,
     
182.                               void* user);
     
183. // 返回通过camera得到的raw data并且携带时间戳
     
184. typedef void (*data_callback_timestamp)(nsecs_t timestamp,
     
185.                                         int32_t msgType,
     
186.                                         const sp<IMemory>& dataPtr,
     
187.                                         void* user);
     
188. 接口如下：
     
189. /** Set the notification and data callbacks */
     
190. virtual void setCallbacks(notify_callback notify_cb,
     
191.                           data_callback data_cb,
     
192.                           data_callback_timestamp data_cb_timestamp,
     
193.                           void* user) = 0;
     
194. 现在又返回到cameraService是如何处理hal发过来的消息
     
195. void CameraService::Client::notifyCallback(int32_t msgType, int32_t ext1,
     
196.         int32_t ext2, void* user) {
     
197.     LOG2("notifyCallback(%d)", msgType);
     
198. 
     
199.     sp<Client> client = getClientFromCookie(user);
     
200.     if (client == 0) return;
     
201.     if (!client->lockIfMessageWanted(msgType)) return;
     
202. 
     
203.     switch (msgType) {//接收到的Hal层消息
     
204.         case CAMERA_MSG_SHUTTER:
     
205.             // ext1 is the dimension of the yuv picture.
     
206.             client->handleShutter((image_rect_type *)ext1);
     
207.             break;
     
208.         default:
     
209.             client->handleGenericNotify(msgType, ext1, ext2);
     
210.             break;
     
211.     }
     
212. }
     
213. 
     
214. void CameraService::Client::dataCallback(int32_t msgType,
     
215.         const sp<IMemory>& dataPtr, void* user) {
     
216.     LOG2("dataCallback(%d)", msgType);
     
217. 
     
218.     sp<Client> client = getClientFromCookie(user);
     
219.     if (client == 0) return;
     
220.     if (!client->lockIfMessageWanted(msgType)) return;
     
221. 
     
222.     if (dataPtr == 0) {
     
223.         LOGE("Null data returned in data callback");
     
224.         client->handleGenericNotify(CAMERA_MSG_ERROR, UNKNOWN_ERROR, 0);
     
225.         return;
     
226.     }
     
227. 
     
228.     switch (msgType) {
     
229.         case CAMERA_MSG_PREVIEW_FRAME:
     
230.             client->handlePreviewData(dataPtr);
     
231.             break;
     
232.         case CAMERA_MSG_POSTVIEW_FRAME:
     
233.             client->handlePostview(dataPtr);
     
234.             break;
     
235.         case CAMERA_MSG_RAW_IMAGE:
     
236.             client->handleRawPicture(dataPtr);
     
237.             break;
     
238.         case CAMERA_MSG_COMPRESSED_IMAGE:
     
239.             client->handleCompressedPicture(dataPtr);
     
240.             break;
     
241.         default:
     
242.             client->handleGenericData(msgType, dataPtr);
     
243.             break;
     
244.     }
     
245. }
     
246. 
     
247. // picture callback - compressed picture ready
     
248. void CameraService::Client::handleCompressedPicture(const sp<IMemory>& mem) {
     
249.     disableMsgType(CAMERA_MSG_COMPRESSED_IMAGE);
     
250. 
     
251.     sp<ICameraClient> c = mCameraClient;
     
252.     mLock.unlock();
     
253. if (c != 0) {
     
254. //回调函数
     
255.         c->dataCallback(CAMERA_MSG_COMPRESSED_IMAGE, mem);
     
256.     }
     
257. }
     
258. 回到frameworks/base/core/java/android/hardware/camera.java 处理消息
     
259. @Override
     
260.         public void handleMessage(Message msg) {
     
261.             switch(msg.what) {
     
262.             case CAMERA_MSG_SHUTTER:
     
263.                 if (mShutterCallback != null) {
     
264.                     mShutterCallback.onShutter();
     
265.                 }
     
266.                 return;
     
267.             ………………
     
268.             case CAMERA_MSG_COMPRESSED_IMAGE:
     
269.                 if (mJpegCallback != null) {
     
270.                     //现在总算回到app时候注册的几个回调函数了
     
271.                     mJpegCallback.onPictureTaken((byte[])msg.obj, mCamera);
     
272.                 }
     
273.                 return;
     
274.             default:
     
275.                 Log.e(TAG, "Unknown message type " + msg.what);
     
276.                 return;
     
277.             }
     
278.         }
     
279. //这里就是存储数据的地方了，这里采用file的形式
     
280. private int storeImage(byte[] data, Location loc) {
     
281.             try {
     
282.                 long dateTaken = System.currentTimeMillis();
     
283.                 String title = createName(dateTaken);
     
284.                 String filename = title + ".jpg";
     
285.                 int[] degree = new int[1];
     
286.                 mLastContentUri = ImageManager.addImage(
     
287.                         mContentResolver,
     
288.                         title,
     
289.                         dateTaken,
     
290.                         loc, // location from gps/network
     
291.                         ImageManager.CAMERA_IMAGE_BUCKET_NAME, filename,
     
292.                         null, data,
     
293.                         degree);
     
294.                 return degree[0];
     
295.             } catch (Exception ex) {
     
296.                 Log.e(TAG, "Exception while compressing image.", ex);
     
297.                 return 0;
     
298.             }
     
299.         }