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