blob: bc259b6f59fc70b442d812aa5245bef13e30007d [file] [log] [blame]
/*
* Copyright (C) 2013 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#define LOG_TAG "Camera3-Stream"
#define ATRACE_TAG ATRACE_TAG_CAMERA
//#define LOG_NDEBUG 0
#include <utils/Log.h>
#include <utils/Trace.h>
#include "Camera3Stream.h"
namespace android {
namespace camera3 {
Camera3Stream::~Camera3Stream() {
}
Camera3Stream* Camera3Stream::cast(camera3_stream *stream) {
return static_cast<Camera3Stream*>(stream);
}
const Camera3Stream* Camera3Stream::cast(const camera3_stream *stream) {
return static_cast<const Camera3Stream*>(stream);
}
Camera3Stream::Camera3Stream(int id,
camera3_stream_type type,
uint32_t width, uint32_t height, size_t maxSize, int format) :
camera3_stream(),
mId(id),
mName(String8::format("Camera3Stream[%d]", id)),
mMaxSize(maxSize),
mState(STATE_CONSTRUCTED) {
camera3_stream::stream_type = type;
camera3_stream::width = width;
camera3_stream::height = height;
camera3_stream::format = format;
camera3_stream::usage = 0;
camera3_stream::max_buffers = 0;
camera3_stream::priv = NULL;
if (format == HAL_PIXEL_FORMAT_BLOB && maxSize == 0) {
ALOGE("%s: BLOB format with size == 0", __FUNCTION__);
mState = STATE_ERROR;
}
}
int Camera3Stream::getId() const {
return mId;
}
uint32_t Camera3Stream::getWidth() const {
return camera3_stream::width;
}
uint32_t Camera3Stream::getHeight() const {
return camera3_stream::height;
}
int Camera3Stream::getFormat() const {
return camera3_stream::format;
}
camera3_stream* Camera3Stream::startConfiguration() {
Mutex::Autolock l(mLock);
switch (mState) {
case STATE_ERROR:
ALOGE("%s: In error state", __FUNCTION__);
return NULL;
case STATE_CONSTRUCTED:
// OK
break;
case STATE_IN_CONFIG:
case STATE_IN_RECONFIG:
// Can start config again with no trouble; but don't redo
// oldUsage/oldMaxBuffers
return this;
case STATE_CONFIGURED:
if (stream_type == CAMERA3_STREAM_INPUT) {
ALOGE("%s: Cannot configure an input stream twice",
__FUNCTION__);
return NULL;
} else if (hasOutstandingBuffersLocked()) {
ALOGE("%s: Cannot configure stream; has outstanding buffers",
__FUNCTION__);
return NULL;
}
break;
default:
ALOGE("%s: Unknown state %d", __FUNCTION__, mState);
return NULL;
}
oldUsage = usage;
oldMaxBuffers = max_buffers;
if (mState == STATE_CONSTRUCTED) {
mState = STATE_IN_CONFIG;
} else { // mState == STATE_CONFIGURED
mState = STATE_IN_RECONFIG;
}
return this;
}
bool Camera3Stream::isConfiguring() const {
Mutex::Autolock l(mLock);
return (mState == STATE_IN_CONFIG) || (mState == STATE_IN_RECONFIG);
}
status_t Camera3Stream::finishConfiguration(camera3_device *hal3Device) {
Mutex::Autolock l(mLock);
switch (mState) {
case STATE_ERROR:
ALOGE("%s: In error state", __FUNCTION__);
return INVALID_OPERATION;
case STATE_IN_CONFIG:
case STATE_IN_RECONFIG:
// OK
break;
case STATE_CONSTRUCTED:
case STATE_CONFIGURED:
ALOGE("%s: Cannot finish configuration that hasn't been started",
__FUNCTION__);
return INVALID_OPERATION;
default:
ALOGE("%s: Unknown state", __FUNCTION__);
return INVALID_OPERATION;
}
// Check if the stream configuration is unchanged, and skip reallocation if
// so. As documented in hardware/camera3.h:configure_streams().
if (mState == STATE_IN_RECONFIG &&
oldUsage == usage &&
oldMaxBuffers == max_buffers) {
mState = STATE_CONFIGURED;
return OK;
}
status_t res;
res = configureQueueLocked();
if (res != OK) {
ALOGE("%s: Unable to configure stream %d queue: %s (%d)",
__FUNCTION__, mId, strerror(-res), res);
mState = STATE_ERROR;
return res;
}
res = registerBuffersLocked(hal3Device);
if (res != OK) {
ALOGE("%s: Unable to register stream buffers with HAL: %s (%d)",
__FUNCTION__, strerror(-res), res);
mState = STATE_ERROR;
return res;
}
mState = STATE_CONFIGURED;
return res;
}
status_t Camera3Stream::getBuffer(camera3_stream_buffer *buffer) {
ATRACE_CALL();
Mutex::Autolock l(mLock);
return getBufferLocked(buffer);
}
status_t Camera3Stream::returnBuffer(const camera3_stream_buffer &buffer,
nsecs_t timestamp) {
ATRACE_CALL();
Mutex::Autolock l(mLock);
return returnBufferLocked(buffer, timestamp);
}
status_t Camera3Stream::getInputBuffer(camera3_stream_buffer *buffer) {
ATRACE_CALL();
Mutex::Autolock l(mLock);
return getInputBufferLocked(buffer);
}
status_t Camera3Stream::returnInputBuffer(const camera3_stream_buffer &buffer) {
ATRACE_CALL();
Mutex::Autolock l(mLock);
return returnInputBufferLocked(buffer);
}
bool Camera3Stream::hasOutstandingBuffers() const {
ATRACE_CALL();
Mutex::Autolock l(mLock);
return hasOutstandingBuffersLocked();
}
status_t Camera3Stream::disconnect() {
ATRACE_CALL();
Mutex::Autolock l(mLock);
return disconnectLocked();
}
status_t Camera3Stream::registerBuffersLocked(camera3_device *hal3Device) {
ATRACE_CALL();
status_t res;
size_t bufferCount = getBufferCountLocked();
Vector<buffer_handle_t*> buffers;
buffers.insertAt(NULL, 0, bufferCount);
camera3_stream_buffer_set bufferSet = camera3_stream_buffer_set();
bufferSet.stream = this;
bufferSet.num_buffers = bufferCount;
bufferSet.buffers = buffers.editArray();
Vector<camera3_stream_buffer_t> streamBuffers;
streamBuffers.insertAt(camera3_stream_buffer_t(), 0, bufferCount);
// Register all buffers with the HAL. This means getting all the buffers
// from the stream, providing them to the HAL with the
// register_stream_buffers() method, and then returning them back to the
// stream in the error state, since they won't have valid data.
//
// Only registered buffers can be sent to the HAL.
uint32_t bufferIdx = 0;
for (; bufferIdx < bufferCount; bufferIdx++) {
res = getBufferLocked( &streamBuffers.editItemAt(bufferIdx) );
if (res != OK) {
ALOGE("%s: Unable to get buffer %d for registration with HAL",
__FUNCTION__, bufferIdx);
// Skip registering, go straight to cleanup
break;
}
sp<Fence> fence = new Fence(streamBuffers[bufferIdx].acquire_fence);
fence->waitForever(kRegisterFenceTimeoutMs,
"Camera3Stream::registerBuffers");
buffers.editItemAt(bufferIdx) = streamBuffers[bufferIdx].buffer;
}
if (bufferIdx == bufferCount) {
// Got all buffers, register with HAL
ALOGV("%s: Registering %d buffers with camera HAL",
__FUNCTION__, bufferCount);
res = hal3Device->ops->register_stream_buffers(hal3Device,
&bufferSet);
}
// Return all valid buffers to stream, in ERROR state to indicate
// they weren't filled.
for (size_t i = 0; i < bufferIdx; i++) {
streamBuffers.editItemAt(i).release_fence = -1;
streamBuffers.editItemAt(i).status = CAMERA3_BUFFER_STATUS_ERROR;
returnBufferLocked(streamBuffers[i], 0);
}
return res;
}
status_t Camera3Stream::getBufferLocked(camera3_stream_buffer *) {
ALOGE("%s: This type of stream does not support output", __FUNCTION__);
return INVALID_OPERATION;
}
status_t Camera3Stream::returnBufferLocked(const camera3_stream_buffer &,
nsecs_t) {
ALOGE("%s: This type of stream does not support output", __FUNCTION__);
return INVALID_OPERATION;
}
status_t Camera3Stream::getInputBufferLocked(camera3_stream_buffer *) {
ALOGE("%s: This type of stream does not support input", __FUNCTION__);
return INVALID_OPERATION;
}
status_t Camera3Stream::returnInputBufferLocked(
const camera3_stream_buffer &) {
ALOGE("%s: This type of stream does not support input", __FUNCTION__);
return INVALID_OPERATION;
}
}; // namespace camera3
}; // namespace android