logo
搜索
我的图书馆

发文章

发文工具

其他工具

留言交流
搜索
分享

android下camera数据流的分析

 Elaine个人小馆 2016-07-14

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. }

  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.     }

  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;

  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.     }

  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;

  76.         //用于判断指定的msg所对应的callback是否可以回调
  77.     enableMsgType(CAMERA_MSG_SHUTTER |
  78.                   CAMERA_MSG_POSTVIEW_FRAME |
  79.                   CAMERA_MSG_RAW_IMAGE |
  80.                   CAMERA_MSG_COMPRESSED_IMAGE);

  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.     }

  112.     spMemoryHeapBase> JpegHeap;
  113.     spMemoryHeapBase> PostviewHeap;
  114.     spMemoryHeapBase> ThumbnailHeap;
  115.     spMemoryBase> buffer = new MemoryBase(mRawHeap, 0, picture_size + 8);

  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.     }

  142.     int JpegImageSize = 10000, JpegExifSize;
  143.     bool isLSISensor = false;
  144.      JpegImageSize = static_castint>(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);

  149. }
  150.     memcpy(static_castunsigned char*>(mPreviewHeap->base()) + offset + (previewWidth*previewHeight * 3 / 2),
  151.             overlay_header, mSizeOfADDRS);

  153.     ret = mOverlay->queueBuffer((void*)(static_castunsigned char *>(mPreviewHeap->base()) + offset +
  154.                                 (previewWidth * previewHeight * 3 / 2)));
  155.     if ((mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE) &&(mSecCamera->getJpegStreamPossible() != true)) {
  156.         spMemoryHeapBase> 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());

  162.         LOGW('JpegExifSize=%d', JpegExifSize);
  163.             unsigned char *ExifStart = (unsigned char *)JpegHeap->base() + 2;
  164.             unsigned char *ImageStart = ExifStart + JpegExifSize;

  166.             memmove(ImageStart, ExifStart, JpegImageSize - 2);
  167.             memcpy(ExifStart, ExifHeap->base(), JpegExifSize);
  168.         spMemoryBase> mem = new MemoryBase(JpegHeap, 0, JpegImageSize + JpegExifSize);
  169.         //压缩格式照片消息
  170.         mDataCb(CAMERA_MSG_COMPRESSED_IMAGE, mem, mCallbackCookie);
  171.     }
  172. }

  174. 现在我们来看下在hal定义的三个回调函数
  175. typedef void (*notify_callback)(int32_t msgType, //用于处理一些通知的消息，如快门
  176.                                 int32_t ext1,
  177.                                 int32_t ext2,
  178.                                 void* user);

  180. typedef void (*data_callback)(int32_t msgType, // 返回通过camera得到的raw data
  181.                               const spIMemory>& dataPtr,
  182.                               void* user);
  183. // 返回通过camera得到的raw data并且携带时间戳
  184. typedef void (*data_callback_timestamp)(nsecs_t timestamp,
  185.                                         int32_t msgType,
  186.                                         const spIMemory>& 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);

  199.     spClient> client = getClientFromCookie(user);
  200.     if (client == 0) return;
  201.     if (!client->lockIfMessageWanted(msgType)) return;

  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. }

  214. void CameraService::Client::dataCallback(int32_t msgType,
  215.         const spIMemory>& dataPtr, void* user) {
  216.     LOG2('dataCallback(%d)', msgType);

  218.     spClient> client = getClientFromCookie(user);
  219.     if (client == 0) return;
  220.     if (!client->lockIfMessageWanted(msgType)) return;

  222.     if (dataPtr == 0) {
  223.         LOGE('Null data returned in data callback');
  224.         client->handleGenericNotify(CAMERA_MSG_ERROR, UNKNOWN_ERROR, 0);
  225.         return;
  226.     }

  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. }

  247. // picture callback - compressed picture ready
  248. void CameraService::Client::handleCompressedPicture(const spIMemory>& mem) {
  249.     disableMsgType(CAMERA_MSG_COMPRESSED_IMAGE);

  251.     spICameraClient> 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.         }

    本站是提供个人知识管理的网络存储空间，所有内容均由用户发布，不代表本站观点。请注意甄别内容中的联系方式、诱导购买等信息，谨防诈骗。如发现有害或侵权内容，请点击一键举报。
    转藏 分享 献花（0）

    来自： Elaine个人小馆 > 《Camera HAL》

    举报/认领

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多