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 32namespace default_camera_hal { 33 34Stream::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 50Stream::~Stream() 51{ 52 android::Mutex::Autolock al(mLock); 53 unregisterBuffers_L(); 54} 55 56void 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 66void 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 76int Stream::getType() 77{ 78 return mType; 79} 80 81bool Stream::isInputType() 82{ 83 return mType == CAMERA3_STREAM_INPUT || 84 mType == CAMERA3_STREAM_BIDIRECTIONAL; 85} 86 87bool Stream::isOutputType() 88{ 89 return mType == CAMERA3_STREAM_OUTPUT || 90 mType == CAMERA3_STREAM_BIDIRECTIONAL; 91} 92 93const 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 106const 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_sRGB_A_8888: 121 return "sRGB A 8888"; 122 case HAL_PIXEL_FORMAT_sRGB_X_8888: 123 return "sRGB B 8888"; 124 case HAL_PIXEL_FORMAT_Y8: 125 return "Y8"; 126 case HAL_PIXEL_FORMAT_Y16: 127 return "Y16"; 128 case HAL_PIXEL_FORMAT_YV12: 129 return "YV12"; 130 case HAL_PIXEL_FORMAT_YCbCr_422_SP: 131 return "NV16"; 132 case HAL_PIXEL_FORMAT_YCrCb_420_SP: 133 return "NV21"; 134 case HAL_PIXEL_FORMAT_YCbCr_422_I: 135 return "YUY2"; 136 case HAL_PIXEL_FORMAT_RAW_SENSOR: 137 return "RAW SENSOR"; 138 case HAL_PIXEL_FORMAT_BLOB: 139 return "BLOB"; 140 case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED: 141 return "IMPLEMENTATION DEFINED"; 142 case HAL_PIXEL_FORMAT_YCbCr_420_888: 143 return "FLEXIBLE YCbCr 420 888"; 144 } 145 return "Invalid stream format!"; 146} 147 148bool Stream::isRegistered() 149{ 150 return mRegistered; 151} 152 153bool Stream::isValidReuseStream(int id, camera3_stream_t *s) 154{ 155 if (id != mId) { 156 ALOGE("%s:%d: Invalid camera id for reuse. Got %d expect %d", 157 __func__, mId, id, mId); 158 return false; 159 } 160 if (s != mStream) { 161 ALOGE("%s:%d: Invalid stream handle for reuse. Got %p expect %p", 162 __func__, mId, s, mStream); 163 return false; 164 } 165 if (s->stream_type != mType) { 166 ALOGE("%s:%d: Mismatched type in reused stream. Got %s(%d) " 167 "expect %s(%d)", __func__, mId, typeToString(s->stream_type), 168 s->stream_type, typeToString(mType), mType); 169 return false; 170 } 171 if (s->format != mFormat) { 172 ALOGE("%s:%d: Mismatched format in reused stream. Got %s(%d) " 173 "expect %s(%d)", __func__, mId, formatToString(s->format), 174 s->format, formatToString(mFormat), mFormat); 175 return false; 176 } 177 if (s->width != mWidth) { 178 ALOGE("%s:%d: Mismatched width in reused stream. Got %d expect %d", 179 __func__, mId, s->width, mWidth); 180 return false; 181 } 182 if (s->height != mHeight) { 183 ALOGE("%s:%d: Mismatched height in reused stream. Got %d expect %d", 184 __func__, mId, s->height, mHeight); 185 return false; 186 } 187 return true; 188} 189 190int Stream::registerBuffers(const camera3_stream_buffer_set_t *buf_set) 191{ 192 ATRACE_CALL(); 193 android::Mutex::Autolock al(mLock); 194 195 if (buf_set->stream != mStream) { 196 ALOGE("%s:%d: Buffer set for invalid stream. Got %p expect %p", 197 __func__, mId, buf_set->stream, mStream); 198 return -EINVAL; 199 } 200 201 mNumBuffers = buf_set->num_buffers; 202 mBuffers = new buffer_handle_t*[mNumBuffers]; 203 204 for (unsigned int i = 0; i < mNumBuffers; i++) { 205 ALOGV("%s:%d: Registering buffer %p", __func__, mId, 206 buf_set->buffers[i]); 207 mBuffers[i] = buf_set->buffers[i]; 208 // TODO: register buffers with hw, handle error cases 209 } 210 mRegistered = true; 211 212 return 0; 213} 214 215// This must only be called with mLock held 216void Stream::unregisterBuffers_L() 217{ 218 mRegistered = false; 219 mNumBuffers = 0; 220 delete [] mBuffers; 221 // TODO: unregister buffers from hw 222} 223 224void Stream::dump(int fd) 225{ 226 android::Mutex::Autolock al(mLock); 227 228 dprintf(fd, "Stream ID: %d (%p)\n", mId, mStream); 229 dprintf(fd, "Stream Type: %s (%d)\n", typeToString(mType), mType); 230 dprintf(fd, "Width: %"PRIu32" Height: %"PRIu32"\n", mWidth, mHeight); 231 dprintf(fd, "Stream Format: %s (%d)", formatToString(mFormat), mFormat); 232 // ToDo: prettyprint usage mask flags 233 dprintf(fd, "Gralloc Usage Mask: %#"PRIx32"\n", mUsage); 234 dprintf(fd, "Max Buffer Count: %"PRIu32"\n", mMaxBuffers); 235 dprintf(fd, "Buffers Registered: %s\n", mRegistered ? "true" : "false"); 236 dprintf(fd, "Number of Buffers: %"PRIu32"\n", mNumBuffers); 237 for (uint32_t i = 0; i < mNumBuffers; i++) { 238 dprintf(fd, "Buffer %"PRIu32"/%"PRIu32": %p\n", i, mNumBuffers, 239 mBuffers[i]); 240 } 241} 242 243} // namespace default_camera_hal 244