1/*
2 * Copyright (C) 2010 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 <stdint.h>
18#include <sys/types.h>
19
20#include <utils/Errors.h>
21#include <utils/RefBase.h>
22#include <utils/Vector.h>
23#include <utils/Timers.h>
24
25#include <binder/Parcel.h>
26#include <binder/IInterface.h>
27
28#include <gui/ISurfaceTexture.h>
29
30namespace android {
31// ----------------------------------------------------------------------------
32
33enum {
34    REQUEST_BUFFER = IBinder::FIRST_CALL_TRANSACTION,
35    SET_BUFFER_COUNT,
36    DEQUEUE_BUFFER,
37    QUEUE_BUFFER,
38    CANCEL_BUFFER,
39    QUERY,
40    SET_SYNCHRONOUS_MODE,
41    CONNECT,
42    DISCONNECT,
43};
44
45
46class BpSurfaceTexture : public BpInterface<ISurfaceTexture>
47{
48public:
49    BpSurfaceTexture(const sp<IBinder>& impl)
50        : BpInterface<ISurfaceTexture>(impl)
51    {
52    }
53
54    virtual status_t requestBuffer(int bufferIdx, sp<GraphicBuffer>* buf) {
55        Parcel data, reply;
56        data.writeInterfaceToken(ISurfaceTexture::getInterfaceDescriptor());
57        data.writeInt32(bufferIdx);
58        status_t result =remote()->transact(REQUEST_BUFFER, data, &reply);
59        if (result != NO_ERROR) {
60            return result;
61        }
62        bool nonNull = reply.readInt32();
63        if (nonNull) {
64            *buf = new GraphicBuffer();
65            reply.read(**buf);
66        }
67        result = reply.readInt32();
68        return result;
69    }
70
71    virtual status_t setBufferCount(int bufferCount)
72    {
73        Parcel data, reply;
74        data.writeInterfaceToken(ISurfaceTexture::getInterfaceDescriptor());
75        data.writeInt32(bufferCount);
76        status_t result =remote()->transact(SET_BUFFER_COUNT, data, &reply);
77        if (result != NO_ERROR) {
78            return result;
79        }
80        result = reply.readInt32();
81        return result;
82    }
83
84    virtual status_t dequeueBuffer(int *buf, sp<Fence>& fence,
85            uint32_t w, uint32_t h, uint32_t format, uint32_t usage) {
86        Parcel data, reply;
87        data.writeInterfaceToken(ISurfaceTexture::getInterfaceDescriptor());
88        data.writeInt32(w);
89        data.writeInt32(h);
90        data.writeInt32(format);
91        data.writeInt32(usage);
92        status_t result = remote()->transact(DEQUEUE_BUFFER, data, &reply);
93        if (result != NO_ERROR) {
94            return result;
95        }
96        *buf = reply.readInt32();
97        fence.clear();
98        bool hasFence = reply.readInt32();
99        if (hasFence) {
100            fence = new Fence();
101            reply.read(*fence.get());
102        }
103        result = reply.readInt32();
104        return result;
105    }
106
107    virtual status_t queueBuffer(int buf,
108            const QueueBufferInput& input, QueueBufferOutput* output) {
109        Parcel data, reply;
110        data.writeInterfaceToken(ISurfaceTexture::getInterfaceDescriptor());
111        data.writeInt32(buf);
112        data.write(input);
113        status_t result = remote()->transact(QUEUE_BUFFER, data, &reply);
114        if (result != NO_ERROR) {
115            return result;
116        }
117        memcpy(output, reply.readInplace(sizeof(*output)), sizeof(*output));
118        result = reply.readInt32();
119        return result;
120    }
121
122    virtual void cancelBuffer(int buf, sp<Fence> fence) {
123        Parcel data, reply;
124        bool hasFence = fence.get() && fence->isValid();
125        data.writeInterfaceToken(ISurfaceTexture::getInterfaceDescriptor());
126        data.writeInt32(buf);
127        data.writeInt32(hasFence);
128        if (hasFence) {
129            data.write(*fence.get());
130        }
131        remote()->transact(CANCEL_BUFFER, data, &reply);
132    }
133
134    virtual int query(int what, int* value) {
135        Parcel data, reply;
136        data.writeInterfaceToken(ISurfaceTexture::getInterfaceDescriptor());
137        data.writeInt32(what);
138        status_t result = remote()->transact(QUERY, data, &reply);
139        if (result != NO_ERROR) {
140            return result;
141        }
142        value[0] = reply.readInt32();
143        result = reply.readInt32();
144        return result;
145    }
146
147    virtual status_t setSynchronousMode(bool enabled) {
148        Parcel data, reply;
149        data.writeInterfaceToken(ISurfaceTexture::getInterfaceDescriptor());
150        data.writeInt32(enabled);
151        status_t result = remote()->transact(SET_SYNCHRONOUS_MODE, data, &reply);
152        if (result != NO_ERROR) {
153            return result;
154        }
155        result = reply.readInt32();
156        return result;
157    }
158
159    virtual status_t connect(int api, QueueBufferOutput* output) {
160        Parcel data, reply;
161        data.writeInterfaceToken(ISurfaceTexture::getInterfaceDescriptor());
162        data.writeInt32(api);
163        status_t result = remote()->transact(CONNECT, data, &reply);
164        if (result != NO_ERROR) {
165            return result;
166        }
167        memcpy(output, reply.readInplace(sizeof(*output)), sizeof(*output));
168        result = reply.readInt32();
169        return result;
170    }
171
172    virtual status_t disconnect(int api) {
173        Parcel data, reply;
174        data.writeInterfaceToken(ISurfaceTexture::getInterfaceDescriptor());
175        data.writeInt32(api);
176        status_t result =remote()->transact(DISCONNECT, data, &reply);
177        if (result != NO_ERROR) {
178            return result;
179        }
180        result = reply.readInt32();
181        return result;
182    }
183};
184
185IMPLEMENT_META_INTERFACE(SurfaceTexture, "android.gui.SurfaceTexture");
186
187// ----------------------------------------------------------------------
188
189status_t BnSurfaceTexture::onTransact(
190    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
191{
192    switch(code) {
193        case REQUEST_BUFFER: {
194            CHECK_INTERFACE(ISurfaceTexture, data, reply);
195            int bufferIdx   = data.readInt32();
196            sp<GraphicBuffer> buffer;
197            int result = requestBuffer(bufferIdx, &buffer);
198            reply->writeInt32(buffer != 0);
199            if (buffer != 0) {
200                reply->write(*buffer);
201            }
202            reply->writeInt32(result);
203            return NO_ERROR;
204        } break;
205        case SET_BUFFER_COUNT: {
206            CHECK_INTERFACE(ISurfaceTexture, data, reply);
207            int bufferCount = data.readInt32();
208            int result = setBufferCount(bufferCount);
209            reply->writeInt32(result);
210            return NO_ERROR;
211        } break;
212        case DEQUEUE_BUFFER: {
213            CHECK_INTERFACE(ISurfaceTexture, data, reply);
214            uint32_t w      = data.readInt32();
215            uint32_t h      = data.readInt32();
216            uint32_t format = data.readInt32();
217            uint32_t usage  = data.readInt32();
218            int buf;
219            sp<Fence> fence;
220            int result = dequeueBuffer(&buf, fence, w, h, format, usage);
221            bool hasFence = fence.get() && fence->isValid();
222            reply->writeInt32(buf);
223            reply->writeInt32(hasFence);
224            if (hasFence) {
225                reply->write(*fence.get());
226            }
227            reply->writeInt32(result);
228            return NO_ERROR;
229        } break;
230        case QUEUE_BUFFER: {
231            CHECK_INTERFACE(ISurfaceTexture, data, reply);
232            int buf = data.readInt32();
233            QueueBufferInput input(data);
234            QueueBufferOutput* const output =
235                    reinterpret_cast<QueueBufferOutput *>(
236                            reply->writeInplace(sizeof(QueueBufferOutput)));
237            status_t result = queueBuffer(buf, input, output);
238            reply->writeInt32(result);
239            return NO_ERROR;
240        } break;
241        case CANCEL_BUFFER: {
242            CHECK_INTERFACE(ISurfaceTexture, data, reply);
243            int buf = data.readInt32();
244            sp<Fence> fence;
245            bool hasFence = data.readInt32();
246            if (hasFence) {
247                fence = new Fence();
248                data.read(*fence.get());
249            }
250            cancelBuffer(buf, fence);
251            return NO_ERROR;
252        } break;
253        case QUERY: {
254            CHECK_INTERFACE(ISurfaceTexture, data, reply);
255            int value;
256            int what = data.readInt32();
257            int res = query(what, &value);
258            reply->writeInt32(value);
259            reply->writeInt32(res);
260            return NO_ERROR;
261        } break;
262        case SET_SYNCHRONOUS_MODE: {
263            CHECK_INTERFACE(ISurfaceTexture, data, reply);
264            bool enabled = data.readInt32();
265            status_t res = setSynchronousMode(enabled);
266            reply->writeInt32(res);
267            return NO_ERROR;
268        } break;
269        case CONNECT: {
270            CHECK_INTERFACE(ISurfaceTexture, data, reply);
271            int api = data.readInt32();
272            QueueBufferOutput* const output =
273                    reinterpret_cast<QueueBufferOutput *>(
274                            reply->writeInplace(sizeof(QueueBufferOutput)));
275            status_t res = connect(api, output);
276            reply->writeInt32(res);
277            return NO_ERROR;
278        } break;
279        case DISCONNECT: {
280            CHECK_INTERFACE(ISurfaceTexture, data, reply);
281            int api = data.readInt32();
282            status_t res = disconnect(api);
283            reply->writeInt32(res);
284            return NO_ERROR;
285        } break;
286    }
287    return BBinder::onTransact(code, data, reply, flags);
288}
289
290// ----------------------------------------------------------------------------
291
292static bool isValid(const sp<Fence>& fence) {
293    return fence.get() && fence->isValid();
294}
295
296ISurfaceTexture::QueueBufferInput::QueueBufferInput(const Parcel& parcel) {
297    parcel.read(*this);
298}
299
300size_t ISurfaceTexture::QueueBufferInput::getFlattenedSize() const
301{
302    return sizeof(timestamp)
303         + sizeof(crop)
304         + sizeof(scalingMode)
305         + sizeof(transform)
306         + sizeof(bool)
307         + (isValid(fence) ? fence->getFlattenedSize() : 0);
308}
309
310size_t ISurfaceTexture::QueueBufferInput::getFdCount() const
311{
312    return isValid(fence) ? fence->getFdCount() : 0;
313}
314
315status_t ISurfaceTexture::QueueBufferInput::flatten(void* buffer, size_t size,
316        int fds[], size_t count) const
317{
318    status_t err = NO_ERROR;
319    bool haveFence = isValid(fence);
320    char* p = (char*)buffer;
321    memcpy(p, &timestamp,   sizeof(timestamp));   p += sizeof(timestamp);
322    memcpy(p, &crop,        sizeof(crop));        p += sizeof(crop);
323    memcpy(p, &scalingMode, sizeof(scalingMode)); p += sizeof(scalingMode);
324    memcpy(p, &transform,   sizeof(transform));   p += sizeof(transform);
325    memcpy(p, &haveFence,   sizeof(haveFence));   p += sizeof(haveFence);
326    if (haveFence) {
327        err = fence->flatten(p, size - (p - (char*)buffer), fds, count);
328    }
329    return err;
330}
331
332status_t ISurfaceTexture::QueueBufferInput::unflatten(void const* buffer,
333        size_t size, int fds[], size_t count)
334{
335    status_t err = NO_ERROR;
336    bool haveFence;
337    const char* p = (const char*)buffer;
338    memcpy(&timestamp,   p, sizeof(timestamp));   p += sizeof(timestamp);
339    memcpy(&crop,        p, sizeof(crop));        p += sizeof(crop);
340    memcpy(&scalingMode, p, sizeof(scalingMode)); p += sizeof(scalingMode);
341    memcpy(&transform,   p, sizeof(transform));   p += sizeof(transform);
342    memcpy(&haveFence,   p, sizeof(haveFence));   p += sizeof(haveFence);
343    if (haveFence) {
344        fence = new Fence();
345        err = fence->unflatten(p, size - (p - (const char*)buffer), fds, count);
346    }
347    return err;
348}
349
350}; // namespace android
351