ISurface.cpp revision 000479f9e325b4e426a67033abd92d47da412725 
1/*
2 * Copyright (C) 2007 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 "ISurface"
18
19#include <stdio.h>
20#include <stdint.h>
21#include <sys/types.h>
22
23#include <binder/Parcel.h>
24#include <binder/IMemory.h>
25
26#include <ui/Overlay.h>
27#include <ui/GraphicBuffer.h>
28
29#include <surfaceflinger/Surface.h>
30#include <surfaceflinger/ISurface.h>
31
32namespace android {
33
34// ----------------------------------------------------------------------
35
36ISurface::BufferHeap::BufferHeap()
37    : w(0), h(0), hor_stride(0), ver_stride(0), format(0),
38    transform(0), flags(0)
39{
40}
41
42ISurface::BufferHeap::BufferHeap(uint32_t w, uint32_t h,
43        int32_t hor_stride, int32_t ver_stride,
44        PixelFormat format, const sp<IMemoryHeap>& heap)
45    : w(w), h(h), hor_stride(hor_stride), ver_stride(ver_stride),
46      format(format), transform(0), flags(0), heap(heap)
47{
48}
49
50ISurface::BufferHeap::BufferHeap(uint32_t w, uint32_t h,
51        int32_t hor_stride, int32_t ver_stride,
52        PixelFormat format, uint32_t transform, uint32_t flags,
53        const sp<IMemoryHeap>& heap)
54        : w(w), h(h), hor_stride(hor_stride), ver_stride(ver_stride),
55          format(format), transform(transform), flags(flags), heap(heap)
56{
57}
58
59
60ISurface::BufferHeap::~BufferHeap()
61{
62}
63
64// ----------------------------------------------------------------------
65
66class BpSurface : public BpInterface<ISurface>
67{
68public:
69    BpSurface(const sp<IBinder>& impl)
70        : BpInterface<ISurface>(impl)
71    {
72    }
73
74    virtual sp<GraphicBuffer> requestBuffer(int bufferIdx, int usage)
75    {
76        Parcel data, reply;
77        data.writeInterfaceToken(ISurface::getInterfaceDescriptor());
78        data.writeInt32(bufferIdx);
79        data.writeInt32(usage);
80        remote()->transact(REQUEST_BUFFER, data, &reply);
81        sp<GraphicBuffer> buffer = new GraphicBuffer(reply);
82        return buffer;
83    }
84
85    virtual status_t registerBuffers(const BufferHeap& buffers)
86    {
87        Parcel data, reply;
88        data.writeInterfaceToken(ISurface::getInterfaceDescriptor());
89        data.writeInt32(buffers.w);
90        data.writeInt32(buffers.h);
91        data.writeInt32(buffers.hor_stride);
92        data.writeInt32(buffers.ver_stride);
93        data.writeInt32(buffers.format);
94        data.writeInt32(buffers.transform);
95        data.writeInt32(buffers.flags);
96        data.writeStrongBinder(buffers.heap->asBinder());
97        remote()->transact(REGISTER_BUFFERS, data, &reply);
98        status_t result = reply.readInt32();
99        return result;
100    }
101
102    virtual void postBuffer(ssize_t offset)
103    {
104        Parcel data, reply;
105        data.writeInterfaceToken(ISurface::getInterfaceDescriptor());
106        data.writeInt32(offset);
107        remote()->transact(POST_BUFFER, data, &reply, IBinder::FLAG_ONEWAY);
108    }
109
110    virtual void unregisterBuffers()
111    {
112        Parcel data, reply;
113        data.writeInterfaceToken(ISurface::getInterfaceDescriptor());
114        remote()->transact(UNREGISTER_BUFFERS, data, &reply);
115    }
116
117    virtual sp<OverlayRef> createOverlay(
118             uint32_t w, uint32_t h, int32_t format, int32_t orientation)
119    {
120        Parcel data, reply;
121        data.writeInterfaceToken(ISurface::getInterfaceDescriptor());
122        data.writeInt32(w);
123        data.writeInt32(h);
124        data.writeInt32(format);
125        data.writeInt32(orientation);
126        remote()->transact(CREATE_OVERLAY, data, &reply);
127        return OverlayRef::readFromParcel(reply);
128    }
129};
130
131IMPLEMENT_META_INTERFACE(Surface, "android.ui.ISurface");
132
133// ----------------------------------------------------------------------
134
135status_t BnSurface::onTransact(
136    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
137{
138    switch(code) {
139        case REQUEST_BUFFER: {
140            CHECK_INTERFACE(ISurface, data, reply);
141            int bufferIdx = data.readInt32();
142            int usage = data.readInt32();
143            sp<GraphicBuffer> buffer(requestBuffer(bufferIdx, usage));
144            return GraphicBuffer::writeToParcel(reply, buffer.get());
145        }
146        case REGISTER_BUFFERS: {
147            CHECK_INTERFACE(ISurface, data, reply);
148            BufferHeap buffer;
149            buffer.w = data.readInt32();
150            buffer.h = data.readInt32();
151            buffer.hor_stride = data.readInt32();
152            buffer.ver_stride= data.readInt32();
153            buffer.format = data.readInt32();
154            buffer.transform = data.readInt32();
155            buffer.flags = data.readInt32();
156            buffer.heap = interface_cast<IMemoryHeap>(data.readStrongBinder());
157            status_t err = registerBuffers(buffer);
158            reply->writeInt32(err);
159            return NO_ERROR;
160        } break;
161        case UNREGISTER_BUFFERS: {
162            CHECK_INTERFACE(ISurface, data, reply);
163            unregisterBuffers();
164            return NO_ERROR;
165        } break;
166        case POST_BUFFER: {
167            CHECK_INTERFACE(ISurface, data, reply);
168            ssize_t offset = data.readInt32();
169            postBuffer(offset);
170            return NO_ERROR;
171        } break;
172        case CREATE_OVERLAY: {
173            CHECK_INTERFACE(ISurface, data, reply);
174            int w = data.readInt32();
175            int h = data.readInt32();
176            int f = data.readInt32();
177            int orientation = data.readInt32();
178            sp<OverlayRef> o = createOverlay(w, h, f, orientation);
179            return OverlayRef::writeToParcel(reply, o);
180        } break;
181        default:
182            return BBinder::onTransact(code, data, reply, flags);
183    }
184}
185
186}; // namespace android
187