Home | History | Annotate | Download | only in camera 
      1 /*
      2  * Copyright (C) 2013 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 <stdio.h>
     18 #include <hardware/camera3.h>
     19 #include <hardware/gralloc.h>
     20 #include <system/graphics.h>
     21 #include <utils/Mutex.h>
     22 
     23 //#define LOG_NDEBUG 0
     24 #define LOG_TAG "Stream"
     25 #include <cutils/log.h>
     26 
     27 #define ATRACE_TAG (ATRACE_TAG_CAMERA | ATRACE_TAG_HAL)
     28 #include <utils/Trace.h>
     29 
     30 #include "Stream.h"
     31 
     32 namespace default_camera_hal {
     33 
     34 Stream::Stream(int id, camera3_stream_t *s)
     35   : mReuse(false),
     36     mId(id),
     37     mStream(s),
     38     mType(s->stream_type),
     39     mWidth(s->width),
     40     mHeight(s->height),
     41     mFormat(s->format),
     42     mUsage(0),
     43     mMaxBuffers(0),
     44     mRegistered(false),
     45     mBuffers(0),
     46     mNumBuffers(0)
     47 {
     48 }
     49 
     50 Stream::~Stream()
     51 {
     52     android::Mutex::Autolock al(mLock);
     53     unregisterBuffers_L();
     54 }
     55 
     56 void Stream::setUsage(uint32_t usage)
     57 {
     58     android::Mutex::Autolock al(mLock);
     59     if (usage != mUsage) {
     60         mUsage = usage;
     61         mStream->usage = usage;
     62         unregisterBuffers_L();
     63     }
     64 }
     65 
     66 void Stream::setMaxBuffers(uint32_t max_buffers)
     67 {
     68     android::Mutex::Autolock al(mLock);
     69     if (max_buffers != mMaxBuffers) {
     70         mMaxBuffers = max_buffers;
     71         mStream->max_buffers = max_buffers;
     72         unregisterBuffers_L();
     73     }
     74 }
     75 
     76 int Stream::getType()
     77 {
     78     return mType;
     79 }
     80 
     81 bool Stream::isInputType()
     82 {
     83     return mType == CAMERA3_STREAM_INPUT ||
     84         mType == CAMERA3_STREAM_BIDIRECTIONAL;
     85 }
     86 
     87 bool Stream::isOutputType()
     88 {
     89     return mType == CAMERA3_STREAM_OUTPUT ||
     90         mType == CAMERA3_STREAM_BIDIRECTIONAL;
     91 }
     92 
     93 const char* Stream::typeToString(int type)
     94 {
     95     switch (type) {
     96     case CAMERA3_STREAM_INPUT:
     97         return "CAMERA3_STREAM_INPUT";
     98     case CAMERA3_STREAM_OUTPUT:
     99         return "CAMERA3_STREAM_OUTPUT";
    100     case CAMERA3_STREAM_BIDIRECTIONAL:
    101         return "CAMERA3_STREAM_BIDIRECTIONAL";
    102     }
    103     return "Invalid stream type!";
    104 }
    105 
    106 const char* Stream::formatToString(int format)
    107 {
    108     // See <system/graphics.h> for full list
    109     switch (format) {
    110     case HAL_PIXEL_FORMAT_BGRA_8888:
    111         return "BGRA 8888";
    112     case HAL_PIXEL_FORMAT_RGBA_8888:
    113         return "RGBA 8888";
    114     case HAL_PIXEL_FORMAT_RGBX_8888:
    115         return "RGBX 8888";
    116     case HAL_PIXEL_FORMAT_RGB_888:
    117         return "RGB 888";
    118     case HAL_PIXEL_FORMAT_RGB_565:
    119         return "RGB 565";
    120     case HAL_PIXEL_FORMAT_Y8:
    121         return "Y8";
    122     case HAL_PIXEL_FORMAT_Y16:
    123         return "Y16";
    124     case HAL_PIXEL_FORMAT_YV12:
    125         return "YV12";
    126     case HAL_PIXEL_FORMAT_YCbCr_422_SP:
    127         return "NV16";
    128     case HAL_PIXEL_FORMAT_YCrCb_420_SP:
    129         return "NV21";
    130     case HAL_PIXEL_FORMAT_YCbCr_422_I:
    131         return "YUY2";
    132     case HAL_PIXEL_FORMAT_RAW10:
    133         return "RAW10";
    134     case HAL_PIXEL_FORMAT_RAW16:
    135         return "RAW16";
    136     case HAL_PIXEL_FORMAT_BLOB:
    137         return "BLOB";
    138     case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED:
    139         return "IMPLEMENTATION DEFINED";
    140     case HAL_PIXEL_FORMAT_YCbCr_420_888:
    141         return "FLEXIBLE YCbCr 420 888";
    142     }
    143     return "Invalid stream format!";
    144 }
    145 
    146 bool Stream::isRegistered()
    147 {
    148     return mRegistered;
    149 }
    150 
    151 bool Stream::isValidReuseStream(int id, camera3_stream_t *s)
    152 {
    153     if (id != mId) {
    154         ALOGE("%s:%d: Invalid camera id for reuse. Got %d expect %d",
    155                 __func__, mId, id, mId);
    156         return false;
    157     }
    158     if (s != mStream) {
    159         ALOGE("%s:%d: Invalid stream handle for reuse. Got %p expect %p",
    160                 __func__, mId, s, mStream);
    161         return false;
    162     }
    163     if (s->stream_type != mType) {
    164         ALOGE("%s:%d: Mismatched type in reused stream. Got %s(%d) "
    165                 "expect %s(%d)", __func__, mId, typeToString(s->stream_type),
    166                 s->stream_type, typeToString(mType), mType);
    167         return false;
    168     }
    169     if (s->format != mFormat) {
    170         ALOGE("%s:%d: Mismatched format in reused stream. Got %s(%d) "
    171                 "expect %s(%d)", __func__, mId, formatToString(s->format),
    172                 s->format, formatToString(mFormat), mFormat);
    173         return false;
    174     }
    175     if (s->width != mWidth) {
    176         ALOGE("%s:%d: Mismatched width in reused stream. Got %d expect %d",
    177                 __func__, mId, s->width, mWidth);
    178         return false;
    179     }
    180     if (s->height != mHeight) {
    181         ALOGE("%s:%d: Mismatched height in reused stream. Got %d expect %d",
    182                 __func__, mId, s->height, mHeight);
    183         return false;
    184     }
    185     return true;
    186 }
    187 
    188 int Stream::registerBuffers(const camera3_stream_buffer_set_t *buf_set)
    189 {
    190     ATRACE_CALL();
    191     android::Mutex::Autolock al(mLock);
    192 
    193     if (buf_set->stream != mStream) {
    194         ALOGE("%s:%d: Buffer set for invalid stream. Got %p expect %p",
    195                 __func__, mId, buf_set->stream, mStream);
    196         return -EINVAL;
    197     }
    198 
    199     mNumBuffers = buf_set->num_buffers;
    200     mBuffers = new buffer_handle_t*[mNumBuffers];
    201 
    202     for (unsigned int i = 0; i < mNumBuffers; i++) {
    203         ALOGV("%s:%d: Registering buffer %p", __func__, mId,
    204                 buf_set->buffers[i]);
    205         mBuffers[i] = buf_set->buffers[i];
    206         // TODO: register buffers with hw, handle error cases
    207     }
    208     mRegistered = true;
    209 
    210     return 0;
    211 }
    212 
    213 // This must only be called with mLock held
    214 void Stream::unregisterBuffers_L()
    215 {
    216     mRegistered = false;
    217     mNumBuffers = 0;
    218     delete [] mBuffers;
    219     // TODO: unregister buffers from hw
    220 }
    221 
    222 void Stream::dump(int fd)
    223 {
    224     android::Mutex::Autolock al(mLock);
    225 
    226     dprintf(fd, "Stream ID: %d (%p)\n", mId, mStream);
    227     dprintf(fd, "Stream Type: %s (%d)\n", typeToString(mType), mType);
    228     dprintf(fd, "Width: %" PRIu32 " Height: %" PRIu32 "\n", mWidth, mHeight);
    229     dprintf(fd, "Stream Format: %s (%d)", formatToString(mFormat), mFormat);
    230     // ToDo: prettyprint usage mask flags
    231     dprintf(fd, "Gralloc Usage Mask: %#" PRIx32 "\n", mUsage);
    232     dprintf(fd, "Max Buffer Count: %" PRIu32 "\n", mMaxBuffers);
    233     dprintf(fd, "Buffers Registered: %s\n", mRegistered ? "true" : "false");
    234     dprintf(fd, "Number of Buffers: %" PRIu32 "\n", mNumBuffers);
    235     for (uint32_t i = 0; i < mNumBuffers; i++) {
    236         dprintf(fd, "Buffer %" PRIu32 "/%" PRIu32 ": %p\n", i, mNumBuffers,
    237                 mBuffers[i]);
    238     }
    239 }
    240 
    241 } // namespace default_camera_hal
    242