Home | History | Annotate | Download | only in camera 
      1 /*
      2 ** Copyright (c) 2011-2012 The Linux Foundation. All rights reserved.
      3 **
      4 ** Licensed under the Apache License, Version 2.0 (the "License");
      5 ** you may not use this file except in compliance with the License.
      6 ** You may obtain a copy of the License at
      7 **
      8 **     http://www.apache.org/licenses/LICENSE-2.0
      9 **
     10 ** Unless required by applicable law or agreed to in writing, software
     11 ** distributed under the License is distributed on an "AS IS" BASIS,
     12 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13 ** See the License for the specific language governing permissions and
     14 ** limitations under the License.
     15 */
     16 
     17 /*#error uncomment this for compiler test!*/
     18 
     19 #define ALOG_NDEBUG 0
     20 #define ALOG_NIDEBUG 0
     21 
     22 #define LOG_TAG __FILE__
     23 #include <utils/Log.h>
     24 #include <utils/threads.h>
     25 
     26 
     27 #include "QCameraStream.h"
     28 
     29 /* QCameraStream class implementation goes here*/
     30 /* following code implement the control logic of this class*/
     31 
     32 namespace android {
     33 
     34 StreamQueue::StreamQueue(){
     35     mInitialized = false;
     36 }
     37 
     38 StreamQueue::~StreamQueue(){
     39     flush();
     40 }
     41 
     42 void StreamQueue::init(){
     43     Mutex::Autolock l(&mQueueLock);
     44     mInitialized = true;
     45     mQueueWait.signal();
     46 }
     47 
     48 void StreamQueue::deinit(){
     49     Mutex::Autolock l(&mQueueLock);
     50     mInitialized = false;
     51     mQueueWait.signal();
     52 }
     53 
     54 bool StreamQueue::isInitialized(){
     55    Mutex::Autolock l(&mQueueLock);
     56    return mInitialized;
     57 }
     58 
     59 bool StreamQueue::enqueue(
     60                  void * element){
     61     Mutex::Autolock l(&mQueueLock);
     62     if(mInitialized == false)
     63         return false;
     64 
     65     mContainer.add(element);
     66     mQueueWait.signal();
     67     return true;
     68 }
     69 
     70 bool StreamQueue::isEmpty(){
     71     return (mInitialized && mContainer.isEmpty());
     72 }
     73 void* StreamQueue::dequeue(){
     74 
     75     void *frame;
     76     mQueueLock.lock();
     77     while(mInitialized && mContainer.isEmpty()){
     78         mQueueWait.wait(mQueueLock);
     79     }
     80 
     81     if(!mInitialized){
     82         mQueueLock.unlock();
     83         return NULL;
     84     }
     85 
     86     frame = mContainer.itemAt(0);
     87     mContainer.removeAt(0);
     88     mQueueLock.unlock();
     89     return frame;
     90 }
     91 
     92 void StreamQueue::flush(){
     93     Mutex::Autolock l(&mQueueLock);
     94     mContainer.clear();
     95 }
     96 
     97 
     98 // ---------------------------------------------------------------------------
     99 // QCameraStream
    100 // ---------------------------------------------------------------------------
    101 
    102 /* initialize a streaming channel*/
    103 status_t QCameraStream::initChannel(int cameraId,
    104                                     uint32_t ch_type_mask)
    105 {
    106 #if 0
    107     int rc = MM_CAMERA_OK;
    108     int i;
    109     status_t ret = NO_ERROR;
    110     int width = 0;  /* width of channel      */
    111     int height = 0; /* height of channel */
    112     cam_ctrl_dimension_t dim;
    113     mm_camera_ch_image_fmt_parm_t fmt;
    114 
    115     memset(&dim, 0, sizeof(cam_ctrl_dimension_t));
    116     rc = cam_config_get_parm(cameraId, MM_CAMERA_PARM_DIMENSION, &dim);
    117     if (MM_CAMERA_OK != rc) {
    118       ALOGE("%s: error - can't get camera dimension!", __func__);
    119       ALOGE("%s: X", __func__);
    120       return BAD_VALUE;
    121     }
    122 
    123     if(MM_CAMERA_CH_PREVIEW_MASK & ch_type_mask) {
    124         rc = cam_ops_ch_acquire(cameraId, MM_CAMERA_CH_PREVIEW);
    125         ALOGV("%s:ch_acquire MM_CAMERA_CH_PREVIEW, rc=%d\n",__func__, rc);
    126 
    127         if(MM_CAMERA_OK != rc) {
    128                 ALOGE("%s: preview channel acquir error =%d\n", __func__, rc);
    129                 ALOGE("%s: X", __func__);
    130                 return BAD_VALUE;
    131         }
    132         else{
    133             memset(&fmt, 0, sizeof(mm_camera_ch_image_fmt_parm_t));
    134             fmt.ch_type = MM_CAMERA_CH_PREVIEW;
    135             fmt.def.fmt = CAMERA_YUV_420_NV12; //dim.prev_format;
    136             fmt.def.dim.width = dim.display_width;
    137             fmt.def.dim.height =  dim.display_height;
    138             ALOGV("%s: preview channel fmt = %d", __func__,
    139                      dim.prev_format);
    140             ALOGV("%s: preview channel resolution = %d X %d", __func__,
    141                      dim.display_width, dim.display_height);
    142 
    143             rc = cam_config_set_parm(cameraId, MM_CAMERA_PARM_CH_IMAGE_FMT, &fmt);
    144             ALOGV("%s: preview MM_CAMERA_PARM_CH_IMAGE_FMT rc = %d\n", __func__, rc);
    145             if(MM_CAMERA_OK != rc) {
    146                     ALOGE("%s:set preview channel format err=%d\n", __func__, ret);
    147                     ALOGE("%s: X", __func__);
    148                     ret = BAD_VALUE;
    149             }
    150         }
    151     }
    152 
    153 
    154     if(MM_CAMERA_CH_VIDEO_MASK & ch_type_mask)
    155     {
    156         rc = cam_ops_ch_acquire(cameraId, MM_CAMERA_CH_VIDEO);
    157         ALOGV("%s:ch_acquire MM_CAMERA_CH_VIDEO, rc=%d\n",__func__, rc);
    158 
    159         if(MM_CAMERA_OK != rc) {
    160                 ALOGE("%s: video channel acquir error =%d\n", __func__, rc);
    161                 ALOGE("%s: X", __func__);
    162                 ret = BAD_VALUE;
    163         }
    164         else {
    165             memset(&fmt, 0, sizeof(mm_camera_ch_image_fmt_parm_t));
    166             fmt.ch_type = MM_CAMERA_CH_VIDEO;
    167             fmt.video.video.fmt = CAMERA_YUV_420_NV12; //dim.enc_format;
    168             fmt.video.video.dim.width = dim.video_width;
    169             fmt.video.video.dim.height = dim.video_height;
    170             ALOGV("%s: video channel fmt = %d", __func__,
    171                      dim.enc_format);
    172             ALOGV("%s: video channel resolution = %d X %d", __func__,
    173                  dim.video_width, dim.video_height);
    174 
    175             rc = cam_config_set_parm(cameraId,  MM_CAMERA_PARM_CH_IMAGE_FMT, &fmt);
    176 
    177             ALOGV("%s: video MM_CAMERA_PARM_CH_IMAGE_FMT rc = %d\n", __func__, rc);
    178             if(MM_CAMERA_OK != rc) {
    179                 ALOGE("%s:set video channel format err=%d\n", __func__, rc);
    180                 ALOGE("%s: X", __func__);
    181                 ret= BAD_VALUE;
    182             }
    183         }
    184 
    185   } /*MM_CAMERA_CH_VIDEO*/
    186 #endif
    187 
    188     int rc = MM_CAMERA_OK;
    189     status_t ret = NO_ERROR;
    190     mm_camera_op_mode_type_t op_mode=MM_CAMERA_OP_MODE_VIDEO;
    191     int i;
    192 
    193     ALOGV("QCameraStream::initChannel : E");
    194     if(MM_CAMERA_CH_PREVIEW_MASK & ch_type_mask){
    195         rc = cam_ops_ch_acquire(cameraId, MM_CAMERA_CH_PREVIEW);
    196         ALOGV("%s:ch_acquire MM_CAMERA_CH_PREVIEW, rc=%d\n",__func__, rc);
    197         if(MM_CAMERA_OK != rc) {
    198                 ALOGE("%s: preview channel acquir error =%d\n", __func__, rc);
    199                 ALOGV("%s: X", __func__);
    200                 return BAD_VALUE;
    201         }
    202         /*Callback register*/
    203         /* register a notify into the mmmm_camera_t object*/
    204        /* ret = cam_evt_register_buf_notify(mCameraId, MM_CAMERA_CH_PREVIEW,
    205                                                 preview_notify_cb,
    206                                                 this);
    207         ALOGV("Buf notify MM_CAMERA_CH_PREVIEW, rc=%d\n",rc);*/
    208     }else if(MM_CAMERA_CH_VIDEO_MASK & ch_type_mask){
    209         rc = cam_ops_ch_acquire(cameraId, MM_CAMERA_CH_VIDEO);
    210         ALOGV("%s:ch_acquire MM_CAMERA_CH_VIDEO, rc=%d\n",__func__, rc);
    211         if(MM_CAMERA_OK != rc) {
    212                 ALOGE("%s: preview channel acquir error =%d\n", __func__, rc);
    213                 ALOGV("%s: X", __func__);
    214                 return BAD_VALUE;
    215         }
    216         /*Callback register*/
    217         /* register a notify into the mmmm_camera_t object*/
    218         /*ret = cam_evt_register_buf_notify(mCameraId, MM_CAMERA_CH_VIDEO,
    219                                                 record_notify_cb,
    220                                                 this);
    221         ALOGV("Buf notify MM_CAMERA_CH_VIDEO, rc=%d\n",rc);*/
    222     }
    223 
    224     ret = (MM_CAMERA_OK==rc)? NO_ERROR : BAD_VALUE;
    225     ALOGV("%s: X, ret = %d", __func__, ret);
    226     return ret;
    227 }
    228 
    229 status_t QCameraStream::deinitChannel(int cameraId,
    230                                     mm_camera_channel_type_t ch_type)
    231 {
    232 
    233     int rc = MM_CAMERA_OK;
    234 
    235     ALOGV("%s: E, channel = %d\n", __func__, ch_type);
    236 
    237     if (MM_CAMERA_CH_MAX <= ch_type) {
    238         ALOGE("%s: X: BAD_VALUE", __func__);
    239         return BAD_VALUE;
    240     }
    241 
    242     cam_ops_ch_release(cameraId, ch_type);
    243 
    244     ALOGV("%s: X, channel = %d\n", __func__, ch_type);
    245     return NO_ERROR;
    246 }
    247 
    248 status_t QCameraStream::setMode(int enable) {
    249   ALOGV("%s :myMode %x ", __func__, myMode);
    250   if (enable) {
    251       myMode = (camera_mode_t)(myMode | CAMERA_ZSL_MODE);
    252   } else {
    253       myMode = (camera_mode_t)(myMode & ~CAMERA_ZSL_MODE);
    254   }
    255   return NO_ERROR;
    256 }
    257 
    258 status_t QCameraStream::setFormat(uint8_t ch_type_mask, cam_format_t previewFmt)
    259 {
    260     int rc = MM_CAMERA_OK;
    261     status_t ret = NO_ERROR;
    262     int width = 0;  /* width of channel      */
    263     int height = 0; /* height of channel */
    264     cam_ctrl_dimension_t dim;
    265     mm_camera_ch_image_fmt_parm_t fmt;
    266     ALOGV("%s: E",__func__);
    267 
    268     memset(&dim, 0, sizeof(cam_ctrl_dimension_t));
    269     rc = cam_config_get_parm(mCameraId, MM_CAMERA_PARM_DIMENSION, &dim);
    270     if (MM_CAMERA_OK != rc) {
    271       ALOGE("%s: error - can't get camera dimension!", __func__);
    272       ALOGV("%s: X", __func__);
    273       return BAD_VALUE;
    274     }
    275     char mDeviceName[PROPERTY_VALUE_MAX];
    276     property_get("ro.product.device",mDeviceName," ");
    277     memset(&fmt, 0, sizeof(mm_camera_ch_image_fmt_parm_t));
    278     if(MM_CAMERA_CH_PREVIEW_MASK & ch_type_mask){
    279         fmt.ch_type = MM_CAMERA_CH_PREVIEW;
    280         fmt.def.fmt = (cam_format_t)previewFmt;
    281         fmt.def.dim.width = dim.display_width;
    282         fmt.def.dim.height =  dim.display_height;
    283     }else if(MM_CAMERA_CH_VIDEO_MASK & ch_type_mask){
    284         fmt.ch_type = MM_CAMERA_CH_VIDEO;
    285         fmt.video.video.fmt = CAMERA_YUV_420_NV21; //dim.enc_format;
    286         fmt.video.video.dim.width = dim.video_width;
    287         fmt.video.video.dim.height = dim.video_height;
    288     }/*else if(MM_CAMERA_CH_SNAPSHOT_MASK & ch_type_mask){
    289         if(mHalCamCtrl->isRawSnapshot()) {
    290             fmt.ch_type = MM_CAMERA_CH_RAW;
    291             fmt.def.fmt = CAMERA_BAYER_SBGGR10;
    292             fmt.def.dim.width = dim.raw_picture_width;
    293             fmt.def.dim.height = dim.raw_picture_height;
    294         }else{
    295             //Jpeg???
    296             fmt.ch_type = MM_CAMERA_CH_SNAPSHOT;
    297             fmt.snapshot.main.fmt = dim.main_img_format;
    298             fmt.snapshot.main.dim.width = dim.picture_width;
    299             fmt.snapshot.main.dim.height = dim.picture_height;
    300 
    301             fmt.snapshot.thumbnail.fmt = dim.thumb_format;
    302             fmt.snapshot.thumbnail.dim.width = dim.ui_thumbnail_width;
    303             fmt.snapshot.thumbnail.dim.height = dim.ui_thumbnail_height;
    304         }
    305     }*/
    306 
    307     rc = cam_config_set_parm(mCameraId, MM_CAMERA_PARM_CH_IMAGE_FMT, &fmt);
    308     ALOGV("%s: Stream MM_CAMERA_PARM_CH_IMAGE_FMT rc = %d\n", __func__, rc);
    309     if(MM_CAMERA_OK != rc) {
    310         ALOGE("%s:set stream channel format err=%d\n", __func__, ret);
    311         ALOGV("%s: X", __func__);
    312         ret = BAD_VALUE;
    313     }
    314     ALOGV("%s: X",__func__);
    315     return ret;
    316 }
    317 
    318 QCameraStream::QCameraStream (){
    319     mInit = false;
    320     mActive = false;
    321     /* memset*/
    322     memset(&mCrop, 0, sizeof(mm_camera_ch_crop_t));
    323 }
    324 
    325 QCameraStream::QCameraStream (int cameraId, camera_mode_t mode)
    326               :mCameraId(cameraId),
    327                myMode(mode)
    328 {
    329     mInit = false;
    330     mActive = false;
    331 
    332     /* memset*/
    333     memset(&mCrop, 0, sizeof(mm_camera_ch_crop_t));
    334 }
    335 
    336 QCameraStream::~QCameraStream () {;}
    337 
    338 
    339 status_t QCameraStream::init() {
    340     return NO_ERROR;
    341 }
    342 
    343 status_t QCameraStream::start() {
    344     return NO_ERROR;
    345 }
    346 
    347 void QCameraStream::stop() {
    348     return;
    349 }
    350 
    351 void QCameraStream::release() {
    352     return;
    353 }
    354 
    355 void QCameraStream::setHALCameraControl(QCameraHardwareInterface* ctrl) {
    356 
    357     /* provide a frame data user,
    358     for the  queue monitor thread to call the busy queue is not empty*/
    359     mHalCamCtrl = ctrl;
    360 }
    361 
    362 }; // namespace android
    363