Home | History | Annotate | Download | only in camera 
      1 /*
      2  * Copyright (C) 2012 The Android Open Source Project
      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 #include <cstdlib>
     18 #include <hardware/camera_common.h>
     19 #include <hardware/hardware.h>
     20 #include "Camera.h"
     21 
     22 //#define LOG_NDEBUG 0
     23 #define LOG_TAG "DefaultCameraHAL"
     24 #include <cutils/log.h>
     25 
     26 #define ATRACE_TAG (ATRACE_TAG_CAMERA | ATRACE_TAG_HAL)
     27 #include <cutils/trace.h>
     28 
     29 #include "CameraHAL.h"
     30 
     31 /*
     32  * This file serves as the entry point to the HAL.  It contains the module
     33  * structure and functions used by the framework to load and interface to this
     34  * HAL, as well as the handles to the individual camera devices.
     35  */
     36 
     37 namespace default_camera_hal {
     38 
     39 // Default Camera HAL has 2 cameras, front and rear.
     40 static CameraHAL gCameraHAL(2);
     41 
     42 CameraHAL::CameraHAL(int num_cameras)
     43   : mNumberOfCameras(num_cameras),
     44     mCallbacks(NULL)
     45 {
     46     int i;
     47 
     48     // Allocate camera array and instantiate camera devices
     49     mCameras = new Camera*[mNumberOfCameras];
     50     for (i = 0; i < mNumberOfCameras; i++) {
     51         mCameras[i] = new Camera(i);
     52     }
     53 }
     54 
     55 CameraHAL::~CameraHAL()
     56 {
     57     int i;
     58 
     59     for (i = 0; i < mNumberOfCameras; i++) {
     60         delete mCameras[i];
     61     }
     62     delete [] mCameras;
     63 }
     64 
     65 int CameraHAL::getNumberOfCameras()
     66 {
     67     ALOGV("%s: %d", __func__, mNumberOfCameras);
     68     return mNumberOfCameras;
     69 }
     70 
     71 int CameraHAL::getCameraInfo(int id, struct camera_info* info)
     72 {
     73     ALOGV("%s: camera id %d: info=%p", __func__, id, info);
     74     if (id < 0 || id >= mNumberOfCameras) {
     75         ALOGE("%s: Invalid camera id %d", __func__, id);
     76         return -ENODEV;
     77     }
     78     // TODO: return device-specific static metadata
     79     return mCameras[id]->getInfo(info);
     80 }
     81 
     82 int CameraHAL::setCallbacks(const camera_module_callbacks_t *callbacks)
     83 {
     84     ALOGV("%s : callbacks=%p", __func__, callbacks);
     85     mCallbacks = callbacks;
     86     return 0;
     87 }
     88 
     89 int CameraHAL::open(const hw_module_t* mod, const char* name, hw_device_t** dev)
     90 {
     91     int id;
     92     char *nameEnd;
     93 
     94     ALOGV("%s: module=%p, name=%s, device=%p", __func__, mod, name, dev);
     95     if (*name == '\0') {
     96         ALOGE("%s: Invalid camera id name is NULL", __func__);
     97         return -EINVAL;
     98     }
     99     id = strtol(name, &nameEnd, 10);
    100     if (*nameEnd != '\0') {
    101         ALOGE("%s: Invalid camera id name %s", __func__, name);
    102         return -EINVAL;
    103     } else if (id < 0 || id >= mNumberOfCameras) {
    104         ALOGE("%s: Invalid camera id %d", __func__, id);
    105         return -ENODEV;
    106     }
    107     return mCameras[id]->open(mod, dev);
    108 }
    109 
    110 extern "C" {
    111 
    112 static int get_number_of_cameras()
    113 {
    114     return gCameraHAL.getNumberOfCameras();
    115 }
    116 
    117 static int get_camera_info(int id, struct camera_info* info)
    118 {
    119     return gCameraHAL.getCameraInfo(id, info);
    120 }
    121 
    122 static int set_callbacks(const camera_module_callbacks_t *callbacks)
    123 {
    124     return gCameraHAL.setCallbacks(callbacks);
    125 }
    126 
    127 static int open_dev(const hw_module_t* mod, const char* name, hw_device_t** dev)
    128 {
    129     return gCameraHAL.open(mod, name, dev);
    130 }
    131 
    132 static hw_module_methods_t gCameraModuleMethods = {
    133     open : open_dev
    134 };
    135 
    136 camera_module_t HAL_MODULE_INFO_SYM __attribute__ ((visibility("default"))) = {
    137     common : {
    138         tag                : HARDWARE_MODULE_TAG,
    139         module_api_version : CAMERA_MODULE_API_VERSION_2_0,
    140         hal_api_version    : HARDWARE_HAL_API_VERSION,
    141         id                 : CAMERA_HARDWARE_MODULE_ID,
    142         name               : "Default Camera HAL",
    143         author             : "The Android Open Source Project",
    144         methods            : &gCameraModuleMethods,
    145         dso                : NULL,
    146         reserved           : {0},
    147     },
    148     get_number_of_cameras : get_number_of_cameras,
    149     get_camera_info       : get_camera_info,
    150     set_callbacks         : set_callbacks
    151 };
    152 } // extern "C"
    153 
    154 } // namespace default_camera_hal
    155