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