Camera3Stream.cpp revision 1754351d9199721e7e7943461689e399ef015260
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#define LOG_TAG "Camera3-Stream" 18#define ATRACE_TAG ATRACE_TAG_CAMERA 19//#define LOG_NDEBUG 0 20 21#include <utils/Log.h> 22#include <utils/Trace.h> 23#include "device3/Camera3Stream.h" 24#include "device3/StatusTracker.h" 25 26#include <cutils/properties.h> 27 28namespace android { 29 30namespace camera3 { 31 32Camera3Stream::~Camera3Stream() { 33 sp<StatusTracker> statusTracker = mStatusTracker.promote(); 34 if (statusTracker != 0 && mStatusId != StatusTracker::NO_STATUS_ID) { 35 statusTracker->removeComponent(mStatusId); 36 } 37} 38 39Camera3Stream* Camera3Stream::cast(camera3_stream *stream) { 40 return static_cast<Camera3Stream*>(stream); 41} 42 43const Camera3Stream* Camera3Stream::cast(const camera3_stream *stream) { 44 return static_cast<const Camera3Stream*>(stream); 45} 46 47Camera3Stream::Camera3Stream(int id, 48 camera3_stream_type type, 49 uint32_t width, uint32_t height, size_t maxSize, int format) : 50 camera3_stream(), 51 mId(id), 52 mName(String8::format("Camera3Stream[%d]", id)), 53 mMaxSize(maxSize), 54 mState(STATE_CONSTRUCTED), 55 mStatusId(StatusTracker::NO_STATUS_ID) { 56 57 camera3_stream::stream_type = type; 58 camera3_stream::width = width; 59 camera3_stream::height = height; 60 camera3_stream::format = format; 61 camera3_stream::usage = 0; 62 camera3_stream::max_buffers = 0; 63 camera3_stream::priv = NULL; 64 65 if (format == HAL_PIXEL_FORMAT_BLOB && maxSize == 0) { 66 ALOGE("%s: BLOB format with size == 0", __FUNCTION__); 67 mState = STATE_ERROR; 68 } 69} 70 71int Camera3Stream::getId() const { 72 return mId; 73} 74 75uint32_t Camera3Stream::getWidth() const { 76 return camera3_stream::width; 77} 78 79uint32_t Camera3Stream::getHeight() const { 80 return camera3_stream::height; 81} 82 83int Camera3Stream::getFormat() const { 84 return camera3_stream::format; 85} 86 87camera3_stream* Camera3Stream::startConfiguration() { 88 ATRACE_CALL(); 89 Mutex::Autolock l(mLock); 90 status_t res; 91 92 switch (mState) { 93 case STATE_ERROR: 94 ALOGE("%s: In error state", __FUNCTION__); 95 return NULL; 96 case STATE_CONSTRUCTED: 97 // OK 98 break; 99 case STATE_IN_CONFIG: 100 case STATE_IN_RECONFIG: 101 // Can start config again with no trouble; but don't redo 102 // oldUsage/oldMaxBuffers 103 return this; 104 case STATE_CONFIGURED: 105 if (stream_type == CAMERA3_STREAM_INPUT) { 106 ALOGE("%s: Cannot configure an input stream twice", 107 __FUNCTION__); 108 return NULL; 109 } else if (hasOutstandingBuffersLocked()) { 110 ALOGE("%s: Cannot configure stream; has outstanding buffers", 111 __FUNCTION__); 112 return NULL; 113 } 114 break; 115 default: 116 ALOGE("%s: Unknown state %d", __FUNCTION__, mState); 117 return NULL; 118 } 119 120 oldUsage = camera3_stream::usage; 121 oldMaxBuffers = camera3_stream::max_buffers; 122 123 res = getEndpointUsage(&(camera3_stream::usage)); 124 if (res != OK) { 125 ALOGE("%s: Cannot query consumer endpoint usage!", 126 __FUNCTION__); 127 return NULL; 128 } 129 130 // Stop tracking if currently doing so 131 if (mStatusId != StatusTracker::NO_STATUS_ID) { 132 sp<StatusTracker> statusTracker = mStatusTracker.promote(); 133 if (statusTracker != 0) { 134 statusTracker->removeComponent(mStatusId); 135 } 136 mStatusId = StatusTracker::NO_STATUS_ID; 137 } 138 139 if (mState == STATE_CONSTRUCTED) { 140 mState = STATE_IN_CONFIG; 141 } else { // mState == STATE_CONFIGURED 142 LOG_ALWAYS_FATAL_IF(mState != STATE_CONFIGURED, "Invalid state: 0x%x", mState); 143 mState = STATE_IN_RECONFIG; 144 } 145 146 return this; 147} 148 149bool Camera3Stream::isConfiguring() const { 150 Mutex::Autolock l(mLock); 151 return (mState == STATE_IN_CONFIG) || (mState == STATE_IN_RECONFIG); 152} 153 154status_t Camera3Stream::finishConfiguration(camera3_device *hal3Device) { 155 ATRACE_CALL(); 156 Mutex::Autolock l(mLock); 157 switch (mState) { 158 case STATE_ERROR: 159 ALOGE("%s: In error state", __FUNCTION__); 160 return INVALID_OPERATION; 161 case STATE_IN_CONFIG: 162 case STATE_IN_RECONFIG: 163 // OK 164 break; 165 case STATE_CONSTRUCTED: 166 case STATE_CONFIGURED: 167 ALOGE("%s: Cannot finish configuration that hasn't been started", 168 __FUNCTION__); 169 return INVALID_OPERATION; 170 default: 171 ALOGE("%s: Unknown state", __FUNCTION__); 172 return INVALID_OPERATION; 173 } 174 175 // Register for idle tracking 176 sp<StatusTracker> statusTracker = mStatusTracker.promote(); 177 if (statusTracker != 0) { 178 mStatusId = statusTracker->addComponent(); 179 } 180 181 // Check if the stream configuration is unchanged, and skip reallocation if 182 // so. As documented in hardware/camera3.h:configure_streams(). 183 if (mState == STATE_IN_RECONFIG && 184 oldUsage == camera3_stream::usage && 185 oldMaxBuffers == camera3_stream::max_buffers) { 186 mState = STATE_CONFIGURED; 187 return OK; 188 } 189 190 status_t res; 191 res = configureQueueLocked(); 192 if (res != OK) { 193 ALOGE("%s: Unable to configure stream %d queue: %s (%d)", 194 __FUNCTION__, mId, strerror(-res), res); 195 mState = STATE_ERROR; 196 return res; 197 } 198 199 res = registerBuffersLocked(hal3Device); 200 if (res != OK) { 201 ALOGE("%s: Unable to register stream buffers with HAL: %s (%d)", 202 __FUNCTION__, strerror(-res), res); 203 mState = STATE_ERROR; 204 return res; 205 } 206 207 mState = STATE_CONFIGURED; 208 209 return res; 210} 211 212status_t Camera3Stream::cancelConfiguration() { 213 ATRACE_CALL(); 214 Mutex::Autolock l(mLock); 215 switch (mState) { 216 case STATE_ERROR: 217 ALOGE("%s: In error state", __FUNCTION__); 218 return INVALID_OPERATION; 219 case STATE_IN_CONFIG: 220 case STATE_IN_RECONFIG: 221 // OK 222 break; 223 case STATE_CONSTRUCTED: 224 case STATE_CONFIGURED: 225 ALOGE("%s: Cannot cancel configuration that hasn't been started", 226 __FUNCTION__); 227 return INVALID_OPERATION; 228 default: 229 ALOGE("%s: Unknown state", __FUNCTION__); 230 return INVALID_OPERATION; 231 } 232 233 camera3_stream::usage = oldUsage; 234 camera3_stream::max_buffers = oldMaxBuffers; 235 236 mState = STATE_CONSTRUCTED; 237 238 return OK; 239} 240 241status_t Camera3Stream::getBuffer(camera3_stream_buffer *buffer) { 242 ATRACE_CALL(); 243 Mutex::Autolock l(mLock); 244 status_t res = OK; 245 246 // This function should be only called when the stream is configured already. 247 if (mState != STATE_CONFIGURED) { 248 ALOGE("%s: Stream %d: Can't get buffers if stream is not in CONFIGURED state %d", 249 __FUNCTION__, mId, mState); 250 return INVALID_OPERATION; 251 } 252 253 // Wait for new buffer returned back if we are running into the limit. 254 if (getHandoutOutputBufferCountLocked() == camera3_stream::max_buffers) { 255 ALOGV("%s: Already dequeued max output buffers (%d), wait for next returned one.", 256 __FUNCTION__, camera3_stream::max_buffers); 257 res = mOutputBufferReturnedSignal.waitRelative(mLock, kWaitForBufferDuration); 258 if (res != OK) { 259 if (res == TIMED_OUT) { 260 ALOGE("%s: wait for output buffer return timed out after %lldms", __FUNCTION__, 261 kWaitForBufferDuration / 1000000LL); 262 } 263 return res; 264 } 265 } 266 267 res = getBufferLocked(buffer); 268 if (res == OK) { 269 fireBufferListenersLocked(*buffer, /*acquired*/true, /*output*/true); 270 } 271 272 return res; 273} 274 275status_t Camera3Stream::returnBuffer(const camera3_stream_buffer &buffer, 276 nsecs_t timestamp) { 277 ATRACE_CALL(); 278 Mutex::Autolock l(mLock); 279 280 /** 281 * TODO: Check that the state is valid first. 282 * 283 * <HAL3.2 IN_CONFIG and IN_RECONFIG in addition to CONFIGURED. 284 * >= HAL3.2 CONFIGURED only 285 * 286 * Do this for getBuffer as well. 287 */ 288 status_t res = returnBufferLocked(buffer, timestamp); 289 if (res == OK) { 290 fireBufferListenersLocked(buffer, /*acquired*/false, /*output*/true); 291 mOutputBufferReturnedSignal.signal(); 292 } 293 294 return res; 295} 296 297status_t Camera3Stream::getInputBuffer(camera3_stream_buffer *buffer) { 298 ATRACE_CALL(); 299 Mutex::Autolock l(mLock); 300 status_t res = OK; 301 302 // This function should be only called when the stream is configured already. 303 if (mState != STATE_CONFIGURED) { 304 ALOGE("%s: Stream %d: Can't get input buffers if stream is not in CONFIGURED state %d", 305 __FUNCTION__, mId, mState); 306 return INVALID_OPERATION; 307 } 308 309 // Wait for new buffer returned back if we are running into the limit. 310 if (getHandoutInputBufferCountLocked() == camera3_stream::max_buffers) { 311 ALOGV("%s: Already dequeued max input buffers (%d), wait for next returned one.", 312 __FUNCTION__, camera3_stream::max_buffers); 313 res = mInputBufferReturnedSignal.waitRelative(mLock, kWaitForBufferDuration); 314 if (res != OK) { 315 if (res == TIMED_OUT) { 316 ALOGE("%s: wait for input buffer return timed out after %lldms", __FUNCTION__, 317 kWaitForBufferDuration / 1000000LL); 318 } 319 return res; 320 } 321 } 322 323 res = getInputBufferLocked(buffer); 324 if (res == OK) { 325 fireBufferListenersLocked(*buffer, /*acquired*/true, /*output*/false); 326 } 327 328 return res; 329} 330 331status_t Camera3Stream::returnInputBuffer(const camera3_stream_buffer &buffer) { 332 ATRACE_CALL(); 333 Mutex::Autolock l(mLock); 334 335 status_t res = returnInputBufferLocked(buffer); 336 if (res == OK) { 337 fireBufferListenersLocked(buffer, /*acquired*/false, /*output*/false); 338 mInputBufferReturnedSignal.signal(); 339 } 340 return res; 341} 342 343void Camera3Stream::fireBufferListenersLocked( 344 const camera3_stream_buffer& /*buffer*/, bool acquired, bool output) { 345 List<wp<Camera3StreamBufferListener> >::iterator it, end; 346 347 // TODO: finish implementing 348 349 Camera3StreamBufferListener::BufferInfo info = 350 Camera3StreamBufferListener::BufferInfo(); 351 info.mOutput = output; 352 // TODO: rest of fields 353 354 for (it = mBufferListenerList.begin(), end = mBufferListenerList.end(); 355 it != end; 356 ++it) { 357 358 sp<Camera3StreamBufferListener> listener = it->promote(); 359 if (listener != 0) { 360 if (acquired) { 361 listener->onBufferAcquired(info); 362 } else { 363 listener->onBufferReleased(info); 364 } 365 } 366 } 367} 368 369bool Camera3Stream::hasOutstandingBuffers() const { 370 ATRACE_CALL(); 371 Mutex::Autolock l(mLock); 372 return hasOutstandingBuffersLocked(); 373} 374 375status_t Camera3Stream::setStatusTracker(sp<StatusTracker> statusTracker) { 376 Mutex::Autolock l(mLock); 377 sp<StatusTracker> oldTracker = mStatusTracker.promote(); 378 if (oldTracker != 0 && mStatusId != StatusTracker::NO_STATUS_ID) { 379 oldTracker->removeComponent(mStatusId); 380 } 381 mStatusId = StatusTracker::NO_STATUS_ID; 382 mStatusTracker = statusTracker; 383 384 return OK; 385} 386 387status_t Camera3Stream::disconnect() { 388 ATRACE_CALL(); 389 Mutex::Autolock l(mLock); 390 ALOGV("%s: Stream %d: Disconnecting...", __FUNCTION__, mId); 391 status_t res = disconnectLocked(); 392 393 if (res == -ENOTCONN) { 394 // "Already disconnected" -- not an error 395 return OK; 396 } else { 397 return res; 398 } 399} 400 401status_t Camera3Stream::registerBuffersLocked(camera3_device *hal3Device) { 402 ATRACE_CALL(); 403 404 /** 405 * >= CAMERA_DEVICE_API_VERSION_3_2: 406 * 407 * camera3_device_t->ops->register_stream_buffers() is not called and must 408 * be NULL. 409 */ 410 if (hal3Device->common.version >= CAMERA_DEVICE_API_VERSION_3_2) { 411 ALOGV("%s: register_stream_buffers unused as of HAL3.2", __FUNCTION__); 412 413 if (hal3Device->ops->register_stream_buffers != NULL) { 414 ALOGE("%s: register_stream_buffers is deprecated in HAL3.2; " 415 "must be set to NULL in camera3_device::ops", __FUNCTION__); 416 return INVALID_OPERATION; 417 } else { 418 ALOGD("%s: Skipping NULL check for deprecated register_stream_buffers", __FUNCTION__); 419 } 420 421 return OK; 422 } else { 423 ALOGV("%s: register_stream_buffers using deprecated code path", __FUNCTION__); 424 } 425 426 status_t res; 427 428 size_t bufferCount = getBufferCountLocked(); 429 430 Vector<buffer_handle_t*> buffers; 431 buffers.insertAt(/*prototype_item*/NULL, /*index*/0, bufferCount); 432 433 camera3_stream_buffer_set bufferSet = camera3_stream_buffer_set(); 434 bufferSet.stream = this; 435 bufferSet.num_buffers = bufferCount; 436 bufferSet.buffers = buffers.editArray(); 437 438 Vector<camera3_stream_buffer_t> streamBuffers; 439 streamBuffers.insertAt(camera3_stream_buffer_t(), /*index*/0, bufferCount); 440 441 // Register all buffers with the HAL. This means getting all the buffers 442 // from the stream, providing them to the HAL with the 443 // register_stream_buffers() method, and then returning them back to the 444 // stream in the error state, since they won't have valid data. 445 // 446 // Only registered buffers can be sent to the HAL. 447 448 uint32_t bufferIdx = 0; 449 for (; bufferIdx < bufferCount; bufferIdx++) { 450 res = getBufferLocked( &streamBuffers.editItemAt(bufferIdx) ); 451 if (res != OK) { 452 ALOGE("%s: Unable to get buffer %d for registration with HAL", 453 __FUNCTION__, bufferIdx); 454 // Skip registering, go straight to cleanup 455 break; 456 } 457 458 sp<Fence> fence = new Fence(streamBuffers[bufferIdx].acquire_fence); 459 fence->waitForever("Camera3Stream::registerBuffers"); 460 461 buffers.editItemAt(bufferIdx) = streamBuffers[bufferIdx].buffer; 462 } 463 if (bufferIdx == bufferCount) { 464 // Got all buffers, register with HAL 465 ALOGV("%s: Registering %zu buffers with camera HAL", 466 __FUNCTION__, bufferCount); 467 ATRACE_BEGIN("camera3->register_stream_buffers"); 468 res = hal3Device->ops->register_stream_buffers(hal3Device, 469 &bufferSet); 470 ATRACE_END(); 471 } 472 473 // Return all valid buffers to stream, in ERROR state to indicate 474 // they weren't filled. 475 for (size_t i = 0; i < bufferIdx; i++) { 476 streamBuffers.editItemAt(i).release_fence = -1; 477 streamBuffers.editItemAt(i).status = CAMERA3_BUFFER_STATUS_ERROR; 478 returnBufferLocked(streamBuffers[i], 0); 479 } 480 481 return res; 482} 483 484status_t Camera3Stream::getBufferLocked(camera3_stream_buffer *) { 485 ALOGE("%s: This type of stream does not support output", __FUNCTION__); 486 return INVALID_OPERATION; 487} 488status_t Camera3Stream::returnBufferLocked(const camera3_stream_buffer &, 489 nsecs_t) { 490 ALOGE("%s: This type of stream does not support output", __FUNCTION__); 491 return INVALID_OPERATION; 492} 493status_t Camera3Stream::getInputBufferLocked(camera3_stream_buffer *) { 494 ALOGE("%s: This type of stream does not support input", __FUNCTION__); 495 return INVALID_OPERATION; 496} 497status_t Camera3Stream::returnInputBufferLocked( 498 const camera3_stream_buffer &) { 499 ALOGE("%s: This type of stream does not support input", __FUNCTION__); 500 return INVALID_OPERATION; 501} 502 503void Camera3Stream::addBufferListener( 504 wp<Camera3StreamBufferListener> listener) { 505 Mutex::Autolock l(mLock); 506 507 List<wp<Camera3StreamBufferListener> >::iterator it, end; 508 for (it = mBufferListenerList.begin(), end = mBufferListenerList.end(); 509 it != end; 510 ) { 511 if (*it == listener) { 512 ALOGE("%s: Try to add the same listener twice, ignoring...", __FUNCTION__); 513 return; 514 } 515 it++; 516 } 517 518 mBufferListenerList.push_back(listener); 519} 520 521void Camera3Stream::removeBufferListener( 522 const sp<Camera3StreamBufferListener>& listener) { 523 Mutex::Autolock l(mLock); 524 525 bool erased = true; 526 List<wp<Camera3StreamBufferListener> >::iterator it, end; 527 for (it = mBufferListenerList.begin(), end = mBufferListenerList.end(); 528 it != end; 529 ) { 530 531 if (*it == listener) { 532 it = mBufferListenerList.erase(it); 533 erased = true; 534 } else { 535 ++it; 536 } 537 } 538 539 if (!erased) { 540 ALOGW("%s: Could not find listener to remove, already removed", 541 __FUNCTION__); 542 } 543} 544 545}; // namespace camera3 546 547}; // namespace android 548