IGraphicBufferProducer.cpp revision 4c00cc11141da7d159eb2323b186ed344115c0f1 
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/IGraphicBufferProducer.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 BpGraphicBufferProducer : public BpInterface<IGraphicBufferProducer>
47{
48public:
49    BpGraphicBufferProducer(const sp<IBinder>& impl)
50        : BpInterface<IGraphicBufferProducer>(impl)
51    {
52    }
53
54    virtual status_t requestBuffer(int bufferIdx, sp<GraphicBuffer>* buf) {
55        Parcel data, reply;
56        data.writeInterfaceToken(IGraphicBufferProducer::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(IGraphicBufferProducer::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(IGraphicBufferProducer::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        bool fenceWasWritten = reply.readInt32();
98        if (fenceWasWritten) {
99            // If the fence was written by the callee, then overwrite the
100            // caller's fence here.  If it wasn't written then don't touch the
101            // caller's fence.
102            *fence = new Fence();
103            reply.read(*(fence->get()));
104        }
105        result = reply.readInt32();
106        return result;
107    }
108
109    virtual status_t queueBuffer(int buf,
110            const QueueBufferInput& input, QueueBufferOutput* output) {
111        Parcel data, reply;
112        data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
113        data.writeInt32(buf);
114        data.write(input);
115        status_t result = remote()->transact(QUEUE_BUFFER, data, &reply);
116        if (result != NO_ERROR) {
117            return result;
118        }
119        memcpy(output, reply.readInplace(sizeof(*output)), sizeof(*output));
120        result = reply.readInt32();
121        return result;
122    }
123
124    virtual void cancelBuffer(int buf, const sp<Fence>& fence) {
125        Parcel data, reply;
126        data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
127        data.writeInt32(buf);
128        data.write(*fence.get());
129        remote()->transact(CANCEL_BUFFER, data, &reply);
130    }
131
132    virtual int query(int what, int* value) {
133        Parcel data, reply;
134        data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
135        data.writeInt32(what);
136        status_t result = remote()->transact(QUERY, data, &reply);
137        if (result != NO_ERROR) {
138            return result;
139        }
140        value[0] = reply.readInt32();
141        result = reply.readInt32();
142        return result;
143    }
144
145    virtual status_t setSynchronousMode(bool enabled) {
146        Parcel data, reply;
147        data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
148        data.writeInt32(enabled);
149        status_t result = remote()->transact(SET_SYNCHRONOUS_MODE, data, &reply);
150        if (result != NO_ERROR) {
151            return result;
152        }
153        result = reply.readInt32();
154        return result;
155    }
156
157    virtual status_t connect(int api, QueueBufferOutput* output) {
158        Parcel data, reply;
159        data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
160        data.writeInt32(api);
161        status_t result = remote()->transact(CONNECT, data, &reply);
162        if (result != NO_ERROR) {
163            return result;
164        }
165        memcpy(output, reply.readInplace(sizeof(*output)), sizeof(*output));
166        result = reply.readInt32();
167        return result;
168    }
169
170    virtual status_t disconnect(int api) {
171        Parcel data, reply;
172        data.writeInterfaceToken(IGraphicBufferProducer::getInterfaceDescriptor());
173        data.writeInt32(api);
174        status_t result =remote()->transact(DISCONNECT, data, &reply);
175        if (result != NO_ERROR) {
176            return result;
177        }
178        result = reply.readInt32();
179        return result;
180    }
181};
182
183IMPLEMENT_META_INTERFACE(GraphicBufferProducer, "android.gui.IGraphicBufferProducer");
184
185// ----------------------------------------------------------------------
186
187status_t BnGraphicBufferProducer::onTransact(
188    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
189{
190    switch(code) {
191        case REQUEST_BUFFER: {
192            CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
193            int bufferIdx   = data.readInt32();
194            sp<GraphicBuffer> buffer;
195            int result = requestBuffer(bufferIdx, &buffer);
196            reply->writeInt32(buffer != 0);
197            if (buffer != 0) {
198                reply->write(*buffer);
199            }
200            reply->writeInt32(result);
201            return NO_ERROR;
202        } break;
203        case SET_BUFFER_COUNT: {
204            CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
205            int bufferCount = data.readInt32();
206            int result = setBufferCount(bufferCount);
207            reply->writeInt32(result);
208            return NO_ERROR;
209        } break;
210        case DEQUEUE_BUFFER: {
211            CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
212            uint32_t w      = data.readInt32();
213            uint32_t h      = data.readInt32();
214            uint32_t format = data.readInt32();
215            uint32_t usage  = data.readInt32();
216            int buf;
217            sp<Fence> fence;
218            int result = dequeueBuffer(&buf, &fence, w, h, format, usage);
219            reply->writeInt32(buf);
220            reply->writeInt32(fence != NULL);
221            if (fence != NULL) {
222                reply->write(*fence.get());
223            }
224            reply->writeInt32(result);
225            return NO_ERROR;
226        } break;
227        case QUEUE_BUFFER: {
228            CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
229            int buf = data.readInt32();
230            QueueBufferInput input(data);
231            QueueBufferOutput* const output =
232                    reinterpret_cast<QueueBufferOutput *>(
233                            reply->writeInplace(sizeof(QueueBufferOutput)));
234            status_t result = queueBuffer(buf, input, output);
235            reply->writeInt32(result);
236            return NO_ERROR;
237        } break;
238        case CANCEL_BUFFER: {
239            CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
240            int buf = data.readInt32();
241            sp<Fence> fence = new Fence();
242            data.read(*fence.get());
243            cancelBuffer(buf, fence);
244            return NO_ERROR;
245        } break;
246        case QUERY: {
247            CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
248            int value;
249            int what = data.readInt32();
250            int res = query(what, &value);
251            reply->writeInt32(value);
252            reply->writeInt32(res);
253            return NO_ERROR;
254        } break;
255        case SET_SYNCHRONOUS_MODE: {
256            CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
257            bool enabled = data.readInt32();
258            status_t res = setSynchronousMode(enabled);
259            reply->writeInt32(res);
260            return NO_ERROR;
261        } break;
262        case CONNECT: {
263            CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
264            int api = data.readInt32();
265            QueueBufferOutput* const output =
266                    reinterpret_cast<QueueBufferOutput *>(
267                            reply->writeInplace(sizeof(QueueBufferOutput)));
268            status_t res = connect(api, output);
269            reply->writeInt32(res);
270            return NO_ERROR;
271        } break;
272        case DISCONNECT: {
273            CHECK_INTERFACE(IGraphicBufferProducer, data, reply);
274            int api = data.readInt32();
275            status_t res = disconnect(api);
276            reply->writeInt32(res);
277            return NO_ERROR;
278        } break;
279    }
280    return BBinder::onTransact(code, data, reply, flags);
281}
282
283// ----------------------------------------------------------------------------
284
285IGraphicBufferProducer::QueueBufferInput::QueueBufferInput(const Parcel& parcel) {
286    parcel.read(*this);
287}
288
289size_t IGraphicBufferProducer::QueueBufferInput::getFlattenedSize() const
290{
291    return sizeof(timestamp)
292         + sizeof(crop)
293         + sizeof(scalingMode)
294         + sizeof(transform)
295         + fence->getFlattenedSize();
296}
297
298size_t IGraphicBufferProducer::QueueBufferInput::getFdCount() const
299{
300    return fence->getFdCount();
301}
302
303status_t IGraphicBufferProducer::QueueBufferInput::flatten(void* buffer, size_t size,
304        int fds[], size_t count) const
305{
306    status_t err = NO_ERROR;
307    char* p = (char*)buffer;
308    memcpy(p, &timestamp,   sizeof(timestamp));   p += sizeof(timestamp);
309    memcpy(p, &crop,        sizeof(crop));        p += sizeof(crop);
310    memcpy(p, &scalingMode, sizeof(scalingMode)); p += sizeof(scalingMode);
311    memcpy(p, &transform,   sizeof(transform));   p += sizeof(transform);
312    err = fence->flatten(p, size - (p - (char*)buffer), fds, count);
313    return err;
314}
315
316status_t IGraphicBufferProducer::QueueBufferInput::unflatten(void const* buffer,
317        size_t size, int fds[], size_t count)
318{
319    status_t err = NO_ERROR;
320    const char* p = (const char*)buffer;
321    memcpy(&timestamp,   p, sizeof(timestamp));   p += sizeof(timestamp);
322    memcpy(&crop,        p, sizeof(crop));        p += sizeof(crop);
323    memcpy(&scalingMode, p, sizeof(scalingMode)); p += sizeof(scalingMode);
324    memcpy(&transform,   p, sizeof(transform));   p += sizeof(transform);
325    fence = new Fence();
326    err = fence->unflatten(p, size - (p - (const char*)buffer), fds, count);
327    return err;
328}
329
330}; // namespace android
331