Chinaunix首页 | 论坛 | 博客

yyxl的ChinaUnix博客yyyw.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

yyxl

  • 博客访问： 3547442
  • 博文数量： 1805
  • 博客积分： 135
  • 博客等级： 入伍新兵
  • 技术积分： 3345
  • 用 户 组： 普通用户
  • 注册时间： 2010-03-19 20:01
文章分类

全部博文（1805）

文章存档

2017年（19）

2016年（80）

2015年（341）

2014年（438）

2013年（349）

2012年（332）

2011年（248）

我的朋友
最近访客
推荐博文
相关博文
Android Camera AppNotifier工作机制分析

分类： Android平台

2013-08-01 08:19:56

原文地址：Android Camera AppNotifier工作机制分析 作者：xinyuwuxian

Android Camera AppNotifier工作机制分析

上面的章节中已经说过了，AppNotifier在initialize的时候会创建并且开启一个线程，这个线程不停的检查是否底层有消息传送过来，如果有消息传送过来，响应的消息会做相应的处理，主要包括以下三种消息：msgQ，mEventQ，mFrameQ，在之前的文章中也同样说到了，这些消息的来源，通过setEventProvider和setFrameProvider设置好消息来源并通过start和setMeasurements开始启动AppCallbackNotifier
这里我们以mFrameQ为例子先做一下说明
  1. void AppCallbackNotifier::frameCallbackRelay(CameraFrame* caFrame)
  2. {
  3.     LOG_FUNCTION_NAME;
  4.     AppCallbackNotifier *appcbn = (AppCallbackNotifier*) (caFrame->mCookie);
  5.     appcbn->frameCallback(caFrame);
  6.     LOG_FUNCTION_NAME_EXIT;
  7. }
底层是通过调用定义好的frameCallbackRelay方法，这个方法调用frameCallback
  1. void AppCallbackNotifier::frameCallback(CameraFrame* caFrame)
  2. {
  3.     ///Post the event to the event queue of AppCallbackNotifier
  4.     TIUTILS::Message msg;
  5.     CameraFrame *frame;

  7.     LOG_FUNCTION_NAME;

  9.     if ( NULL != caFrame )
  10.         {

  12.         frame = new CameraFrame(*caFrame);
  13.         if ( NULL != frame )
  14.             {
  15.               msg.command = AppCallbackNotifier::NOTIFIER_CMD_PROCESS_FRAME;
  16.               msg.arg1 = frame;
  17.               mFrameQ.put(&msg);
  18.             }
  19.         else
  20.             {
  21.             CAMHAL_LOGEA("Not enough resources to allocate CameraFrame");
  22.             }

  24.         }

  26.     LOG_FUNCTION_NAME_EXIT;
  27. }
这里首先new CameraFrame，保存回调回来的数据，让后使用put方法将这个消息放进mFrameQ堆栈，所以上面说过的那个一直运行的线程就可以检查到有消息到来，开始干活处理
那么我们真正关注的是，这个frameCallbackRelay是怎么与底层实现关联的啊？地层是怎样通过这个方法实现回调的呢？
这里我们就要追究一下这个frameCallbackRelay是怎么样和底层实现关联的了
mFrameProvider = new FrameProvider(frameNotifier, this, frameCallbackRelay);
先看这里，在new FrameProvider的时候传入了这个framecallback方法，在FrameProvider的构造函数中将这个函数指针保存到mFrameCallback中，方法如下：
  1. FrameProvider(FrameNotifier *fn, void* cookie, frame_callback frameCallback)
  2.         :mFrameNotifier(fn), mCookie(cookie),mFrameCallback(frameCallback) { }
然后在CameraHal的初始化setFrameProvider的方式中调用一下语句
mFrameProvider->enableFrameNotification(CameraFrame::IMAGE_FRAME);
mFrameProvider->enableFrameNotification(CameraFrame::RAW_FRAME);
我们就看看enableFrameNotification的实现吧，他的实现在CameraHalUtilClasses中
  1. int FrameProvider::enableFrameNotification(int32_t frameTypes)
  2. {
  3.     LOG_FUNCTION_NAME;
  4.     status_t ret = NO_ERROR;

  6.     ///Enable the frame notification to CameraAdapter (which implements FrameNotifier interface)
  7.     mFrameNotifier->enableMsgType(frameTypes<<MessageNotifier::FRAME_BIT_FIELD_POSITION, mFrameCallback , NULL, mCookie);

  9.     LOG_FUNCTION_NAME_EXIT;
  10.     return ret;
  11. }
说一下上面这个方法，这里调用了我们上面FrameProvider构造函数中保存下来的，我们接着看看enableMsgType的实现，在BaseCameraAdapter中
  1. void BaseCameraAdapter::enableMsgType(int32_t msgs, frame_callback callback, event_callback eventCb, void* cookie)
  2. {
  3.     Mutex::Autolock lock(mSubscriberLock);

  5.     LOG_FUNCTION_NAME;

  7.     int32_t frameMsg = ((msgs >> MessageNotifier::FRAME_BIT_FIELD_POSITION) & EVENT_MASK);
  8.     int32_t eventMsg = ((msgs >> MessageNotifier::EVENT_BIT_FIELD_POSITION) & EVENT_MASK);

  10.     if ( frameMsg != 0 )
  11.         {
  12.         CAMHAL_LOGVB("Frame message type id=0x%x subscription request", frameMsg);
  13.         switch ( frameMsg )
  14.             {
  15.             case CameraFrame::PREVIEW_FRAME_SYNC:
  16.                 mFrameSubscribers.add((int) cookie, callback);
  17.                 break;
  18.             case CameraFrame::FRAME_DATA_SYNC:
  19.                 mFrameDataSubscribers.add((int) cookie, callback);
  20.                 break;
  21.             case CameraFrame::SNAPSHOT_FRAME:
  22.                 mSnapshotSubscribers.add((int) cookie, callback);
  23.                 break;
  24.             case CameraFrame::IMAGE_FRAME:
  25.                 mImageSubscribers.add((int) cookie, callback);
  26.                 break;
  27.             case CameraFrame::RAW_FRAME:
  28.                 mRawSubscribers.add((int) cookie, callback);
  29.                 break;
  30.             case CameraFrame::VIDEO_FRAME_SYNC:
  31.                 mVideoSubscribers.add((int) cookie, callback);
  32.                 break;
  33.             case CameraFrame::REPROCESS_INPUT_FRAME:
  34.                 mVideoInSubscribers.add((int) cookie, callback);
  35.                 break;
  36.             default:
  37.                 CAMHAL_LOGEA("Frame message type id=0x%x subscription no supported yet!", frameMsg);
  38.                 break;
  39.             }
  40.         }

  42.     if ( eventMsg != 0)
  43.         {
  44.         CAMHAL_LOGVB("Event message type id=0x%x subscription request", eventMsg);
  45.         if ( CameraHalEvent::ALL_EVENTS == eventMsg )
  46.             {
  47.             mFocusSubscribers.add((int) cookie, eventCb);
  48.             mShutterSubscribers.add((int) cookie, eventCb);
  49.             mZoomSubscribers.add((int) cookie, eventCb);
  50.             mMetadataSubscribers.add((int) cookie, eventCb);
  51.             }
  52.         else
  53.             {
  54.             CAMHAL_LOGEA("Event message type id=0x%x subscription no supported yet!", eventMsg);
  55.             }
  56.         }

  58.     LOG_FUNCTION_NAME_EXIT;
  59. }
这里出现很多的向量表，我们看一下这几个向量表mFrameDataSubscribers，mImageSubscribers，mRawSubscribers
在这里将我们初始化定义好的callback方法加入向量表中，底层到底怎么调用到还是不知道啊，接着找啊找
跟上一篇文章是一样的，之前采用V4LCameraAdapter的方式分析其实我们早就在之前文章中说过了，这里这篇文章我们针对OMXCameraAdapter做分析
在OMXCameraAdapter中有这样一个方法
  1. status_t OMXCameraAdapter::sendCallBacks(CameraFrame frame, OMX_IN OMX_BUFFERHEADERTYPE *pBuffHeader, unsigned int mask, OMXCameraPortParameters *port)
  2. {
  3.   status_t ret = NO_ERROR;

  5.   LOG_FUNCTION_NAME;

  7.   if ( NULL == port)
  8.     {
  9.       CAMHAL_LOGEA("Invalid portParam");
  10.       return -EINVAL;
  11.     }

  13.   if ( NULL == pBuffHeader )
  14.     {
  15.       CAMHAL_LOGEA("Invalid Buffer header");
  16.       return -EINVAL;
  17.     }

  19.   Mutex::Autolock lock(mSubscriberLock);

  21.   //frame.mFrameType = typeOfFrame;
  22.   frame.mFrameMask = mask;
  23.   frame.mBuffer = (CameraBuffer *)pBuffHeader->pAppPrivate;
  24.   frame.mLength = pBuffHeader->nFilledLen;
  25.   frame.mAlignment = port->mStride;
  26.   frame.mOffset = pBuffHeader->nOffset;
  27.   frame.mWidth = port->mWidth;
  28.   frame.mHeight = port->mHeight;
  29.   frame.mYuv[0] = NULL;
  30.   frame.mYuv[1] = NULL;

  32.   if ( onlyOnce && mRecording )
  33.     {
  34.       mTimeSourceDelta = (pBuffHeader->nTimeStamp * 1000) - systemTime(SYSTEM_TIME_MONOTONIC);
  35.       onlyOnce = false;
  36.     }

  38.   frame.mTimestamp = (pBuffHeader->nTimeStamp * 1000) - mTimeSourceDelta;

  40.   ret = setInitFrameRefCount(frame.mBuffer, mask);

  42.   if (ret != NO_ERROR) {
  43.      CAMHAL_LOGDB("Error in setInitFrameRefCount %d", ret);
  44.   } else {
  45.       ret = sendFrameToSubscribers(&frame);
  46.   }

  48.   CAMHAL_LOGVB("B 0x%x T %llu", frame.mBuffer, pBuffHeader->nTimeStamp);

  50.   LOG_FUNCTION_NAME_EXIT;

  52.   return ret;
  53. }
这里这个方法其实和V4LCameraAdapter中的使用方法是很类似的，先是填充CameraFrame这个结构，最后通过sendFrameToSubscribers这个方法，我们看看这个方法吧
这个方法在BaseCameraAdapter中实现
  1. status_t BaseCameraAdapter::sendFrameToSubscribers(CameraFrame *frame)
  2. {
  3.     status_t ret = NO_ERROR;
  4.     unsigned int mask;

  6.     if ( NULL == frame )
  7.         {
  8.         CAMHAL_LOGEA("Invalid CameraFrame");
  9.         return -EINVAL;
  10.         }

  12.     for( mask = 1; mask < CameraFrame::ALL_FRAMES; mask <<= 1){
  13.       if( mask & frame->mFrameMask ){
  14.         switch( mask ){

  16.         case CameraFrame::IMAGE_FRAME:
  17.           {
  18. #if PPM_INSTRUMENTATION || PPM_INSTRUMENTATION_ABS
  19.             CameraHal::PPM("Shot to Jpeg: ", &mStartCapture);
  20. #endif
  21.             ret = __sendFrameToSubscribers(frame, &mImageSubscribers, CameraFrame::IMAGE_FRAME);
  22.           }
  23.           break;
  24.         case CameraFrame::RAW_FRAME:
  25.           {
  26.             ret = __sendFrameToSubscribers(frame, &mRawSubscribers, CameraFrame::RAW_FRAME);
  27.           }
  28.           break;
  29.         case CameraFrame::PREVIEW_FRAME_SYNC:
  30.           {
  31.             ret = __sendFrameToSubscribers(frame, &mFrameSubscribers, CameraFrame::PREVIEW_FRAME_SYNC);
  32.           }
  33.           break;
  34.         case CameraFrame::SNAPSHOT_FRAME:
  35.           {
  36.             ret = __sendFrameToSubscribers(frame, &mSnapshotSubscribers, CameraFrame::SNAPSHOT_FRAME);
  37.           }
  38.           break;
  39.         case CameraFrame::VIDEO_FRAME_SYNC:
  40.           {
  41.             ret = __sendFrameToSubscribers(frame, &mVideoSubscribers, CameraFrame::VIDEO_FRAME_SYNC);
  42.           }
  43.           break;
  44.         case CameraFrame::FRAME_DATA_SYNC:
  45.           {
  46.             ret = __sendFrameToSubscribers(frame, &mFrameDataSubscribers, CameraFrame::FRAME_DATA_SYNC);
  47.           }
  48.           break;
  49.         case CameraFrame::REPROCESS_INPUT_FRAME:
  50.           {
  51.             ret = __sendFrameToSubscribers(frame, &mVideoInSubscribers, CameraFrame::REPROCESS_INPUT_FRAME);
  52.           }
  53.           break;
  54.         default:
  55.           CAMHAL_LOGEB("FRAMETYPE NOT SUPPORTED 0x%x", mask);
  56.         break;
  57.         }//SWITCH
  58.         frame->mFrameMask &= ~mask;

  60.         if (ret != NO_ERROR) {
  61.             goto EXIT;
  62.         }
  63.       }//IF
  64.     }//FOR

  66.  EXIT:
  67.     return ret;
  68. }
他接着调用上面标出的方法，到这里我们发现V4LCameraAdapter和OMXCameraAdapter使用的是同一个方法与AppNotifier实现交互，BaseCameraAdapter作为一个接口使用
我们接着看看上面标注部分的实现，其实之前早就说过了
  1. status_t BaseCameraAdapter::__sendFrameToSubscribers(CameraFrame* frame,
  2.                                                      KeyedVector<int, frame_callback> *subscribers,
  3.                                                      CameraFrame::FrameType frameType)
  4. {
  5.     size_t refCount = 0;
  6.     status_t ret = NO_ERROR;
  7.     frame_callback callback = NULL;

  9.     frame->mFrameType = frameType;

  11.     if ( (frameType == CameraFrame::PREVIEW_FRAME_SYNC) ||
  12.          (frameType == CameraFrame::VIDEO_FRAME_SYNC) ||
  13.          (frameType == CameraFrame::SNAPSHOT_FRAME) ){
  14.         if (mFrameQueue.size() > 0){
  15.           CameraFrame *lframe = (CameraFrame *)mFrameQueue.valueFor(frame->mBuffer);
  16.           frame->mYuv[0] = lframe->mYuv[0];
  17.           frame->mYuv[1] = frame->mYuv[0] + (frame->mLength + frame->mOffset)*2/3;
  18.         }
  19.         else{
  20.           CAMHAL_LOGDA("Empty Frame Queue");
  21.           return -EINVAL;
  22.         }
  23.       }

  25.     if (NULL != subscribers) {
  26.         refCount = getFrameRefCount(frame->mBuffer, frameType);

  28.         if (refCount == 0) {
  29.             CAMHAL_LOGDA("Invalid ref count of 0");
  30.             return -EINVAL;
  31.         }

  33.         if (refCount > subscribers->size()) {
  34.             CAMHAL_LOGEB("Invalid ref count for frame type: 0x%x", frameType);
  35.             return -EINVAL;
  36.         }

  38.         CAMHAL_LOGVB("Type of Frame: 0x%x address: 0x%x refCount start %d",
  39.                      frame->mFrameType,
  40.                      ( uint32_t ) frame->mBuffer,
  41.                      refCount);

  43.         for ( unsigned int i = 0 ; i < refCount; i++ ) {
  44.             frame->mCookie = ( void * ) subscribers->keyAt(i);
  45.             callback = (frame_callback) subscribers->valueAt(i);

  47.             if (!callback) {
  48.                 CAMHAL_LOGEB("callback not set for frame type: 0x%x", frameType);
  49.                 return -EINVAL;
  50.             }

  52.             callback(frame);
  53.         }
  54.     } else {
  55.         CAMHAL_LOGEA("Subscribers is null??");
  56.         return -EINVAL;
  57.     }

  59.     return ret;
  60. }
在上面这个方法中，通过对应的向量表找到需要的callback方法，最终调用callback方法，这里调用的这个callback方法其实就是我们上面初始化定义的callback方法，到这里其实底层与AppNotifier已经实现了关联，不过我们并没有花很多时间去说明底层是如何通过OMX方式与kernel driver进行交互最后获取到数据并调用上面的sendcallback方法的，这里之后要单独作为一个章节去研究；同样，我们也还没有好好的去说明一下AppNotifier又是怎么样一步一步把数据真正的递交到上层app手中的，这里简单说明一下吧
上面已经说过了，AppNotifier在构造的时候会创建并启动一个线程检查是否有消息到达，消息到达则进行相应的分类处理
这里只针对notifyFrame进行分析
  1. void AppCallbackNotifier::notifyFrame()
  2. {
  3.     ///Receive and send the frame notifications to app
  4.     TIUTILS::Message msg;
  5.     CameraFrame *frame;
  6.     MemoryHeapBase *heap;
  7.     MemoryBase *buffer = NULL;
  8.     sp<MemoryBase> memBase;
  9.     void *buf = NULL;

  11.     LOG_FUNCTION_NAME;

  13.     {
  14.         Mutex::Autolock lock(mLock);
  15.         if(!mFrameQ.isEmpty()) {
  16.             mFrameQ.get(&msg);
  17.         } else {
  18.             return;
  19.         }
  20.     }

  22.     bool ret = true;

  24.     frame = NULL;
  25.     switch(msg.command)
  26.         {
  27.         case AppCallbackNotifier::NOTIFIER_CMD_PROCESS_FRAME:

  29.                 frame = (CameraFrame *) msg.arg1;
  30.                 if(!frame)
  31.                     {
  32.                     break;
  33.                     }

  35.                 if ( (CameraFrame::RAW_FRAME == frame->mFrameType )&&
  36.                     ( NULL != mCameraHal ) &&
  37.                     ( NULL != mDataCb) &&
  38.                     ( NULL != mNotifyCb ) )
  39.                     {

  41.                     if ( mCameraHal->msgTypeEnabled(CAMERA_MSG_RAW_IMAGE) )
  42.                         {
  43. #ifdef COPY_IMAGE_BUFFER
  44.                         copyAndSendPictureFrame(frame, CAMERA_MSG_RAW_IMAGE);
  45. #else
  46.                         //TODO: Find a way to map a Tiler buffer to a MemoryHeapBase
  47. #endif
  48.                         }
  49.                     else {
  50.                         if ( mCameraHal->msgTypeEnabled(CAMERA_MSG_RAW_IMAGE_NOTIFY) ) {
  51.                             mNotifyCb(CAMERA_MSG_RAW_IMAGE_NOTIFY, 0, 0, mCallbackCookie);
  52.                         }
  53.                         mFrameProvider->returnFrame(frame->mBuffer,
  54.                                                     (CameraFrame::FrameType) frame->mFrameType);
  55.                     }

  57.                     mRawAvailable = true;

  59.                     }
  60.                 else if ( (CameraFrame::IMAGE_FRAME == frame->mFrameType) &&
  61.                           (NULL != mCameraHal) &&
  62.                           (NULL != mDataCb) &&
  63.                           (CameraFrame::ENCODE_RAW_YUV422I_TO_JPEG & frame->mQuirks) )
  64.                     {

  66.                     int encode_quality = 100, tn_quality = 100;
  67.                     int tn_width, tn_height;
  68.                     unsigned int current_snapshot = 0;
  69.                     Encoder_libjpeg::params *main_jpeg = NULL, *tn_jpeg = NULL;
  70.                     void* exif_data = NULL;
  71.                     const char *previewFormat = NULL;
  72.                     camera_memory_t* raw_picture = mRequestMemory(-1, frame->mLength, 1, NULL);

  74.                     if(raw_picture) {
  75.                         buf = raw_picture->data;
  76.                     }

  78.                     CameraParameters parameters;
  79.                     char *params = mCameraHal->getParameters();
  80.                     const String8 strParams(params);
  81.                     parameters.unflatten(strParams);

  83.                     encode_quality = parameters.getInt(CameraParameters::KEY_JPEG_QUALITY);
  84.                     if (encode_quality < 0 || encode_quality > 100) {
  85.                         encode_quality = 100;
  86.                     }

  88.                     tn_quality = parameters.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY);
  89.                     if (tn_quality < 0 || tn_quality > 100) {
  90.                         tn_quality = 100;
  91.                     }

  93.                     if (CameraFrame::HAS_EXIF_DATA & frame->mQuirks) {
  94.                         exif_data = frame->mCookie2;
  95.                     }

  97.                     main_jpeg = (Encoder_libjpeg::params*)
  98.                                     malloc(sizeof(Encoder_libjpeg::params));

  100.                     // Video snapshot with LDCNSF on adds a few bytes start offset
  101.                     // and a few bytes on every line. They must be skipped.
  102.                     int rightCrop = frame->mAlignment/2 - frame->mWidth;

  104.                     CAMHAL_LOGDB("Video snapshot right crop = %d", rightCrop);
  105.                     CAMHAL_LOGDB("Video snapshot offset = %d", frame->mOffset);

  107.                     if (main_jpeg) {
  108.                         main_jpeg->src = (uint8_t *)frame->mBuffer->mapped;
  109.                         main_jpeg->src_size = frame->mLength;
  110.                         main_jpeg->dst = (uint8_t*) buf;
  111.                         main_jpeg->dst_size = frame->mLength;
  112.                         main_jpeg->quality = encode_quality;
  113.                         main_jpeg->in_width = frame->mAlignment/2; // use stride here
  114.                         main_jpeg->in_height = frame->mHeight;
  115.                         main_jpeg->out_width = frame->mAlignment/2;
  116.                         main_jpeg->out_height = frame->mHeight;
  117.                         main_jpeg->right_crop = rightCrop;
  118.                         main_jpeg->start_offset = frame->mOffset;
  119.                         if ( CameraFrame::FORMAT_YUV422I_UYVY & frame->mQuirks) {
  120.                             main_jpeg->format = TICameraParameters::PIXEL_FORMAT_YUV422I_UYVY;
  121.                         }
  122.                         else { //if ( CameraFrame::FORMAT_YUV422I_YUYV & frame->mQuirks)
  123.                             main_jpeg->format = CameraParameters::PIXEL_FORMAT_YUV422I;
  124.                         }
  125.                     }

  127.                     tn_width = parameters.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH);
  128.                     tn_height = parameters.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT);
  129.                     previewFormat = parameters.getPreviewFormat();

  131.                     if ((tn_width > 0) && (tn_height > 0) && ( NULL != previewFormat )) {
  132.                         tn_jpeg = (Encoder_libjpeg::params*)
  133.                                       malloc(sizeof(Encoder_libjpeg::params));
  134.                         // if malloc fails just keep going and encode main jpeg
  135.                         if (!tn_jpeg) {
  136.                             tn_jpeg = NULL;
  137.                         }
  138.                     }

  140.                     if (tn_jpeg) {
  141.                         int width, height;
  142.                         parameters.getPreviewSize(&width,&height);
  143.                         current_snapshot = (mPreviewBufCount + MAX_BUFFERS - 1) % MAX_BUFFERS;
  144.                         tn_jpeg->src = (uint8_t *)mPreviewBuffers[current_snapshot].mapped;
  145.                         tn_jpeg->src_size = mPreviewMemory->size / MAX_BUFFERS;
  146.                         tn_jpeg->dst_size = calculateBufferSize(tn_width,
  147.                                                                 tn_height,
  148.                                                                 previewFormat);
  149.                         tn_jpeg->dst = (uint8_t*) malloc(tn_jpeg->dst_size);
  150.                         tn_jpeg->quality = tn_quality;
  151.                         tn_jpeg->in_width = width;
  152.                         tn_jpeg->in_height = height;
  153.                         tn_jpeg->out_width = tn_width;
  154.                         tn_jpeg->out_height = tn_height;
  155.                         tn_jpeg->right_crop = 0;
  156.                         tn_jpeg->start_offset = 0;
  157.                         tn_jpeg->format = CameraParameters::PIXEL_FORMAT_YUV420SP;;
  158.                     }

  160.                     sp<Encoder_libjpeg> encoder = new Encoder_libjpeg(main_jpeg,
  161.                                                       tn_jpeg,
  162.                                                       AppCallbackNotifierEncoderCallback,
  163.                                                       (CameraFrame::FrameType)frame->mFrameType,
  164.                                                       this,
  165.                                                       raw_picture,
  166.                                                       exif_data, frame->mBuffer);
  167.                     gEncoderQueue.add(frame->mBuffer->mapped, encoder);
  168.                     encoder->run();
  169.                     encoder.clear();
  170.                     if (params != NULL)
  171.                       {
  172.                         mCameraHal->putParameters(params);
  173.                       }
  174.                     }
  175.                 else if ( ( CameraFrame::IMAGE_FRAME == frame->mFrameType ) &&
  176.                              ( NULL != mCameraHal ) &&
  177.                              ( NULL != mDataCb) )
  178.                     {

  180.                     // CTS, MTS requirements: Every 'takePicture()' call
  181.                     // who registers a raw callback should receive one
  182.                     // as well. This is not always the case with
  183.                     // CameraAdapters though.
  184.                     if (!mCameraHal->msgTypeEnabled(CAMERA_MSG_RAW_IMAGE)) {
  185.                         dummyRaw();
  186.                     } else {
  187.                         mRawAvailable = false;
  188.                     }

  190. #ifdef COPY_IMAGE_BUFFER
  191.                     {
  192.                         Mutex::Autolock lock(mBurstLock);
  193. #if defined(OMAP_ENHANCEMENT)
  194.                         if ( mBurst )
  195.                         {
  196.                             copyAndSendPictureFrame(frame, CAMERA_MSG_COMPRESSED_BURST_IMAGE);
  197.                         }
  198.                         else
  199. #endif
  200.                         {
  201.                             copyAndSendPictureFrame(frame, CAMERA_MSG_COMPRESSED_IMAGE);
  202.                         }
  203.                     }
  204. #else
  205.                      //TODO: Find a way to map a Tiler buffer to a MemoryHeapBase
  206. #endif
  207.                     }
  208.                 else if ( ( CameraFrame::VIDEO_FRAME_SYNC == frame->mFrameType ) &&
  209.                              ( NULL != mCameraHal ) &&
  210.                              ( NULL != mDataCb) &&
  211.                              ( mCameraHal->msgTypeEnabled(CAMERA_MSG_VIDEO_FRAME) ) )
  212.                     {
  213.                     AutoMutex locker(mRecordingLock);
  214.                     if(mRecording)
  215.                         {
  216.                         if(mUseMetaDataBufferMode)
  217.                             {
  218.                             camera_memory_t *videoMedatadaBufferMemory =
  219.                                              mVideoMetadataBufferMemoryMap.valueFor(frame->mBuffer->opaque);
  220.                             video_metadata_t *videoMetadataBuffer = (video_metadata_t *) videoMedatadaBufferMemory->data;

  222.                             if( (NULL == videoMedatadaBufferMemory) || (NULL == videoMetadataBuffer) || (NULL == frame->mBuffer) )
  223.                                 {
  224.                                 CAMHAL_LOGEA("Error! One of the video buffers is NULL");
  225.                                 break;
  226.                                 }

  228.                             if ( mUseVideoBuffers )
  229.                               {
  230.                                 CameraBuffer *vBuf = mVideoMap.valueFor(frame->mBuffer->opaque);
  231.                                 GraphicBufferMapper &mapper = GraphicBufferMapper::get();
  232.                                 Rect bounds;
  233.                                 bounds.left = 0;
  234.                                 bounds.top = 0;
  235.                                 bounds.right = mVideoWidth;
  236.                                 bounds.bottom = mVideoHeight;

  238.                                 void *y_uv[2];
  239.                                 mapper.lock((buffer_handle_t)vBuf, CAMHAL_GRALLOC_USAGE, bounds, y_uv);
  240.                                 y_uv[1] = y_uv[0] + mVideoHeight*4096;

  242.                                 structConvImage input = {frame->mWidth,
  243.                                                           frame->mHeight,
  244.                                                           4096,
  245.                                                           IC_FORMAT_YCbCr420_lp,
  246.                                                           (mmByte *)frame->mYuv[0],
  247.                                                           (mmByte *)frame->mYuv[1],
  248.                                                           frame->mOffset};

  250.                                 structConvImage output = {mVideoWidth,
  251.                                                           mVideoHeight,
  252.                                                           4096,
  253.                                                           IC_FORMAT_YCbCr420_lp,
  254.                                                           (mmByte *)y_uv[0],
  255.                                                           (mmByte *)y_uv[1],
  256.                                                           0};

  258.                                 VT_resizeFrame_Video_opt2_lp(&input, &output, NULL, 0);
  259.                                 mapper.unlock((buffer_handle_t)vBuf->opaque);
  260.                                 videoMetadataBuffer->metadataBufferType = (int) kMetadataBufferTypeCameraSource;
  261.                                 /* FIXME remove cast */
  262.                                 videoMetadataBuffer->handle = (void *)vBuf->opaque;
  263.                                 videoMetadataBuffer->offset = 0;
  264.                               }
  265.                             else
  266.                               {
  267.                                 videoMetadataBuffer->metadataBufferType = (int) kMetadataBufferTypeCameraSource;
  268.                                 videoMetadataBuffer->handle = camera_buffer_get_omx_ptr(frame->mBuffer);
  269.                                 videoMetadataBuffer->offset = frame->mOffset;
  270.                               }

  272.                             CAMHAL_LOGVB("mDataCbTimestamp : frame->mBuffer=0x%x, videoMetadataBuffer=0x%x, videoMedatadaBufferMemory=0x%x",
  273.                                             frame->mBuffer->opaque, videoMetadataBuffer, videoMedatadaBufferMemory);

  275.                             mDataCbTimestamp(frame->mTimestamp, CAMERA_MSG_VIDEO_FRAME,
  276.                                                 videoMedatadaBufferMemory, 0, mCallbackCookie);
  277.                             }
  278.                         else
  279.                             {
  280.                             //TODO: Need to revisit this, should ideally be mapping the TILER buffer using mRequestMemory
  281.                             camera_memory_t* fakebuf = mRequestMemory(-1, sizeof(buffer_handle_t), 1, NULL);
  282.                             if( (NULL == fakebuf) || ( NULL == fakebuf->data) || ( NULL == frame->mBuffer))
  283.                                 {
  284.                                 CAMHAL_LOGEA("Error! One of the video buffers is NULL");
  285.                                 break;
  286.                                 }

  288.                             *reinterpret_cast<buffer_handle_t*>(fakebuf->data) = reinterpret_cast<buffer_handle_t>(frame->mBuffer->mapped);
  289.                             mDataCbTimestamp(frame->mTimestamp, CAMERA_MSG_VIDEO_FRAME, fakebuf, 0, mCallbackCookie);
  290.                             fakebuf->release(fakebuf);
  291.                             }
  292.                         }
  293.                     }
  294.                 else if(( CameraFrame::SNAPSHOT_FRAME == frame->mFrameType ) &&
  295.                              ( NULL != mCameraHal ) &&
  296.                              ( NULL != mDataCb) &&
  297.                              ( NULL != mNotifyCb)) {
  298.                     //When enabled, measurement data is sent instead of video data
  299.                     if ( !mMeasurementEnabled ) {
  300.                         copyAndSendPreviewFrame(frame, CAMERA_MSG_POSTVIEW_FRAME);
  301.                     } else {
  302.                         mFrameProvider->returnFrame(frame->mBuffer,
  303.                                                     (CameraFrame::FrameType) frame->mFrameType);
  304.                     }
  305.                 }
  306.                 else if ( ( CameraFrame::PREVIEW_FRAME_SYNC== frame->mFrameType ) &&
  307.                             ( NULL != mCameraHal ) &&
  308.                             ( NULL != mDataCb) &&
  309.                             ( mCameraHal->msgTypeEnabled(CAMERA_MSG_PREVIEW_FRAME)) ) {
  310.                     //When enabled, measurement data is sent instead of video data
  311.                     if ( !mMeasurementEnabled ) {
  312.                         copyAndSendPreviewFrame(frame, CAMERA_MSG_PREVIEW_FRAME);
  313.                     } else {
  314.                          mFrameProvider->returnFrame(frame->mBuffer,
  315.                                                      (CameraFrame::FrameType) frame->mFrameType);
  316.                     }
  317.                 }
  318.                 else if ( ( CameraFrame::FRAME_DATA_SYNC == frame->mFrameType ) &&
  319.                             ( NULL != mCameraHal ) &&
  320.                             ( NULL != mDataCb) &&
  321.                             ( mCameraHal->msgTypeEnabled(CAMERA_MSG_PREVIEW_FRAME)) ) {
  322.                     copyAndSendPreviewFrame(frame, CAMERA_MSG_PREVIEW_FRAME);
  323.                 } else {
  324.                     mFrameProvider->returnFrame(frame->mBuffer,
  325.                                                 ( CameraFrame::FrameType ) frame->mFrameType);
  326.                     CAMHAL_LOGDB("Frame type 0x%x is still unsupported!", frame->mFrameType);
  327.                 }

  329.                 break;

  331.         default:

  333.             break;

  335.         };

  337. exit:

  339.     if ( NULL != frame )
  340.         {
  341.         delete frame;
  342.         }

  344.     LOG_FUNCTION_NAME_EXIT;
  345. }
以上按照相应方式处理消息，returnFrame，copyAndSendPicture，还有一些回调函数，这些都是很重要的，这里先不做过多研究，在之前的文章中其实也已经提到过，数据怎样最终上传到app层

待续。。。
阅读(799) | 评论(0) | 转发(0) |
0

上一篇：ffmpeg主要数据结构及其之间的关系

下一篇：Android Camera OMXCameraAdapter.cpp初始化分析

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6