f785754009
ISurfaceTexture::dequeueBuffer now returns the buffer's fence for the client to wait on. For BufferQueue, this means passing it through Binder so it can be returned to the SurfaceTextureClient. Now SurfaceTextureClient is responsible for waiting on the fence in dequeueBuffer instead of BufferQueue: one step closer to the goal. Change-Id: I677ae758bcd23acee2d784b8cec11b32cccc196d
283 lines
9.4 KiB
C++
283 lines
9.4 KiB
C++
/*
|
|
* Copyright (C) 2010 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.
|
|
*/
|
|
|
|
#include <stdint.h>
|
|
#include <sys/types.h>
|
|
|
|
#include <utils/Errors.h>
|
|
#include <utils/RefBase.h>
|
|
#include <utils/Vector.h>
|
|
#include <utils/Timers.h>
|
|
|
|
#include <binder/Parcel.h>
|
|
#include <binder/IInterface.h>
|
|
|
|
#include <gui/ISurfaceTexture.h>
|
|
|
|
namespace android {
|
|
// ----------------------------------------------------------------------------
|
|
|
|
enum {
|
|
REQUEST_BUFFER = IBinder::FIRST_CALL_TRANSACTION,
|
|
SET_BUFFER_COUNT,
|
|
DEQUEUE_BUFFER,
|
|
QUEUE_BUFFER,
|
|
CANCEL_BUFFER,
|
|
QUERY,
|
|
SET_SYNCHRONOUS_MODE,
|
|
CONNECT,
|
|
DISCONNECT,
|
|
};
|
|
|
|
|
|
class BpSurfaceTexture : public BpInterface<ISurfaceTexture>
|
|
{
|
|
public:
|
|
BpSurfaceTexture(const sp<IBinder>& impl)
|
|
: BpInterface<ISurfaceTexture>(impl)
|
|
{
|
|
}
|
|
|
|
virtual status_t requestBuffer(int bufferIdx, sp<GraphicBuffer>* buf) {
|
|
Parcel data, reply;
|
|
data.writeInterfaceToken(ISurfaceTexture::getInterfaceDescriptor());
|
|
data.writeInt32(bufferIdx);
|
|
status_t result =remote()->transact(REQUEST_BUFFER, data, &reply);
|
|
if (result != NO_ERROR) {
|
|
return result;
|
|
}
|
|
bool nonNull = reply.readInt32();
|
|
if (nonNull) {
|
|
*buf = new GraphicBuffer();
|
|
reply.read(**buf);
|
|
}
|
|
result = reply.readInt32();
|
|
return result;
|
|
}
|
|
|
|
virtual status_t setBufferCount(int bufferCount)
|
|
{
|
|
Parcel data, reply;
|
|
data.writeInterfaceToken(ISurfaceTexture::getInterfaceDescriptor());
|
|
data.writeInt32(bufferCount);
|
|
status_t result =remote()->transact(SET_BUFFER_COUNT, data, &reply);
|
|
if (result != NO_ERROR) {
|
|
return result;
|
|
}
|
|
result = reply.readInt32();
|
|
return result;
|
|
}
|
|
|
|
virtual status_t dequeueBuffer(int *buf, sp<Fence>& fence,
|
|
uint32_t w, uint32_t h, uint32_t format, uint32_t usage) {
|
|
Parcel data, reply;
|
|
data.writeInterfaceToken(ISurfaceTexture::getInterfaceDescriptor());
|
|
data.writeInt32(w);
|
|
data.writeInt32(h);
|
|
data.writeInt32(format);
|
|
data.writeInt32(usage);
|
|
status_t result = remote()->transact(DEQUEUE_BUFFER, data, &reply);
|
|
if (result != NO_ERROR) {
|
|
return result;
|
|
}
|
|
*buf = reply.readInt32();
|
|
fence.clear();
|
|
bool hasFence = reply.readInt32();
|
|
if (hasFence) {
|
|
fence = new Fence();
|
|
reply.read(*fence.get());
|
|
}
|
|
result = reply.readInt32();
|
|
return result;
|
|
}
|
|
|
|
virtual status_t queueBuffer(int buf,
|
|
const QueueBufferInput& input, QueueBufferOutput* output) {
|
|
Parcel data, reply;
|
|
data.writeInterfaceToken(ISurfaceTexture::getInterfaceDescriptor());
|
|
data.writeInt32(buf);
|
|
memcpy(data.writeInplace(sizeof(input)), &input, sizeof(input));
|
|
status_t result = remote()->transact(QUEUE_BUFFER, data, &reply);
|
|
if (result != NO_ERROR) {
|
|
return result;
|
|
}
|
|
memcpy(output, reply.readInplace(sizeof(*output)), sizeof(*output));
|
|
result = reply.readInt32();
|
|
return result;
|
|
}
|
|
|
|
virtual void cancelBuffer(int buf) {
|
|
Parcel data, reply;
|
|
data.writeInterfaceToken(ISurfaceTexture::getInterfaceDescriptor());
|
|
data.writeInt32(buf);
|
|
remote()->transact(CANCEL_BUFFER, data, &reply);
|
|
}
|
|
|
|
virtual int query(int what, int* value) {
|
|
Parcel data, reply;
|
|
data.writeInterfaceToken(ISurfaceTexture::getInterfaceDescriptor());
|
|
data.writeInt32(what);
|
|
status_t result = remote()->transact(QUERY, data, &reply);
|
|
if (result != NO_ERROR) {
|
|
return result;
|
|
}
|
|
value[0] = reply.readInt32();
|
|
result = reply.readInt32();
|
|
return result;
|
|
}
|
|
|
|
virtual status_t setSynchronousMode(bool enabled) {
|
|
Parcel data, reply;
|
|
data.writeInterfaceToken(ISurfaceTexture::getInterfaceDescriptor());
|
|
data.writeInt32(enabled);
|
|
status_t result = remote()->transact(SET_SYNCHRONOUS_MODE, data, &reply);
|
|
if (result != NO_ERROR) {
|
|
return result;
|
|
}
|
|
result = reply.readInt32();
|
|
return result;
|
|
}
|
|
|
|
virtual status_t connect(int api, QueueBufferOutput* output) {
|
|
Parcel data, reply;
|
|
data.writeInterfaceToken(ISurfaceTexture::getInterfaceDescriptor());
|
|
data.writeInt32(api);
|
|
status_t result = remote()->transact(CONNECT, data, &reply);
|
|
if (result != NO_ERROR) {
|
|
return result;
|
|
}
|
|
memcpy(output, reply.readInplace(sizeof(*output)), sizeof(*output));
|
|
result = reply.readInt32();
|
|
return result;
|
|
}
|
|
|
|
virtual status_t disconnect(int api) {
|
|
Parcel data, reply;
|
|
data.writeInterfaceToken(ISurfaceTexture::getInterfaceDescriptor());
|
|
data.writeInt32(api);
|
|
status_t result =remote()->transact(DISCONNECT, data, &reply);
|
|
if (result != NO_ERROR) {
|
|
return result;
|
|
}
|
|
result = reply.readInt32();
|
|
return result;
|
|
}
|
|
};
|
|
|
|
IMPLEMENT_META_INTERFACE(SurfaceTexture, "android.gui.SurfaceTexture");
|
|
|
|
// ----------------------------------------------------------------------
|
|
|
|
status_t BnSurfaceTexture::onTransact(
|
|
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
|
|
{
|
|
switch(code) {
|
|
case REQUEST_BUFFER: {
|
|
CHECK_INTERFACE(ISurfaceTexture, data, reply);
|
|
int bufferIdx = data.readInt32();
|
|
sp<GraphicBuffer> buffer;
|
|
int result = requestBuffer(bufferIdx, &buffer);
|
|
reply->writeInt32(buffer != 0);
|
|
if (buffer != 0) {
|
|
reply->write(*buffer);
|
|
}
|
|
reply->writeInt32(result);
|
|
return NO_ERROR;
|
|
} break;
|
|
case SET_BUFFER_COUNT: {
|
|
CHECK_INTERFACE(ISurfaceTexture, data, reply);
|
|
int bufferCount = data.readInt32();
|
|
int result = setBufferCount(bufferCount);
|
|
reply->writeInt32(result);
|
|
return NO_ERROR;
|
|
} break;
|
|
case DEQUEUE_BUFFER: {
|
|
CHECK_INTERFACE(ISurfaceTexture, data, reply);
|
|
uint32_t w = data.readInt32();
|
|
uint32_t h = data.readInt32();
|
|
uint32_t format = data.readInt32();
|
|
uint32_t usage = data.readInt32();
|
|
int buf;
|
|
sp<Fence> fence;
|
|
int result = dequeueBuffer(&buf, fence, w, h, format, usage);
|
|
reply->writeInt32(buf);
|
|
reply->writeInt32(fence.get() != NULL);
|
|
if (fence.get() != NULL) {
|
|
reply->write(*fence.get());
|
|
}
|
|
reply->writeInt32(result);
|
|
return NO_ERROR;
|
|
} break;
|
|
case QUEUE_BUFFER: {
|
|
CHECK_INTERFACE(ISurfaceTexture, data, reply);
|
|
int buf = data.readInt32();
|
|
QueueBufferInput const* const input =
|
|
reinterpret_cast<QueueBufferInput const *>(
|
|
data.readInplace(sizeof(QueueBufferInput)));
|
|
QueueBufferOutput* const output =
|
|
reinterpret_cast<QueueBufferOutput *>(
|
|
reply->writeInplace(sizeof(QueueBufferOutput)));
|
|
status_t result = queueBuffer(buf, *input, output);
|
|
reply->writeInt32(result);
|
|
return NO_ERROR;
|
|
} break;
|
|
case CANCEL_BUFFER: {
|
|
CHECK_INTERFACE(ISurfaceTexture, data, reply);
|
|
int buf = data.readInt32();
|
|
cancelBuffer(buf);
|
|
return NO_ERROR;
|
|
} break;
|
|
case QUERY: {
|
|
CHECK_INTERFACE(ISurfaceTexture, data, reply);
|
|
int value;
|
|
int what = data.readInt32();
|
|
int res = query(what, &value);
|
|
reply->writeInt32(value);
|
|
reply->writeInt32(res);
|
|
return NO_ERROR;
|
|
} break;
|
|
case SET_SYNCHRONOUS_MODE: {
|
|
CHECK_INTERFACE(ISurfaceTexture, data, reply);
|
|
bool enabled = data.readInt32();
|
|
status_t res = setSynchronousMode(enabled);
|
|
reply->writeInt32(res);
|
|
return NO_ERROR;
|
|
} break;
|
|
case CONNECT: {
|
|
CHECK_INTERFACE(ISurfaceTexture, data, reply);
|
|
int api = data.readInt32();
|
|
QueueBufferOutput* const output =
|
|
reinterpret_cast<QueueBufferOutput *>(
|
|
reply->writeInplace(sizeof(QueueBufferOutput)));
|
|
status_t res = connect(api, output);
|
|
reply->writeInt32(res);
|
|
return NO_ERROR;
|
|
} break;
|
|
case DISCONNECT: {
|
|
CHECK_INTERFACE(ISurfaceTexture, data, reply);
|
|
int api = data.readInt32();
|
|
status_t res = disconnect(api);
|
|
reply->writeInt32(res);
|
|
return NO_ERROR;
|
|
} break;
|
|
}
|
|
return BBinder::onTransact(code, data, reply, flags);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
}; // namespace android
|