blob: 5ab72cd3710a37b01508ec387c942d55201526bd [file] [log] [blame]
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001/*
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 "Surface"
18
19#include <stdint.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080020#include <errno.h>
21#include <sys/types.h>
22#include <sys/stat.h>
23
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080024#include <utils/Errors.h>
25#include <utils/threads.h>
Mathias Agopiancbb288b2009-09-07 16:32:45 -070026#include <utils/CallStack.h>
Mathias Agopian9cce3252010-02-09 17:46:37 -080027#include <utils/Log.h>
28
Mathias Agopianc5b2c0b2009-05-19 19:08:10 -070029#include <binder/IPCThreadState.h>
30#include <binder/IMemory.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080031
Mathias Agopian076b1cc2009-04-10 14:24:30 -070032#include <ui/DisplayInfo.h>
Mathias Agopian3330b202009-10-05 17:07:12 -070033#include <ui/GraphicBuffer.h>
34#include <ui/GraphicBufferMapper.h>
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080035#include <ui/Rect.h>
36
Mathias Agopian9cce3252010-02-09 17:46:37 -080037#include <surfaceflinger/Surface.h>
38#include <surfaceflinger/ISurface.h>
39#include <surfaceflinger/ISurfaceComposer.h>
40#include <surfaceflinger/SurfaceComposerClient.h>
Mathias Agopian076b1cc2009-04-10 14:24:30 -070041
Mathias Agopian9cce3252010-02-09 17:46:37 -080042#include <private/surfaceflinger/SharedBufferStack.h>
43#include <private/surfaceflinger/LayerState.h>
Mathias Agopian076b1cc2009-04-10 14:24:30 -070044
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -080045namespace android {
46
Mathias Agopian076b1cc2009-04-10 14:24:30 -070047// ----------------------------------------------------------------------
48
Mathias Agopian14998592009-07-13 18:29:59 -070049static status_t copyBlt(
Mathias Agopian3330b202009-10-05 17:07:12 -070050 const sp<GraphicBuffer>& dst,
51 const sp<GraphicBuffer>& src,
Mathias Agopian0926f502009-05-04 14:17:04 -070052 const Region& reg)
Mathias Agopian076b1cc2009-04-10 14:24:30 -070053{
Mathias Agopian245e4d72010-04-21 15:24:11 -070054 // src and dst with, height and format must be identical. no verification
55 // is done here.
Mathias Agopian14998592009-07-13 18:29:59 -070056 status_t err;
57 uint8_t const * src_bits = NULL;
58 err = src->lock(GRALLOC_USAGE_SW_READ_OFTEN, reg.bounds(), (void**)&src_bits);
59 LOGE_IF(err, "error locking src buffer %s", strerror(-err));
Mathias Agopian0926f502009-05-04 14:17:04 -070060
Mathias Agopian14998592009-07-13 18:29:59 -070061 uint8_t* dst_bits = NULL;
62 err = dst->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, reg.bounds(), (void**)&dst_bits);
63 LOGE_IF(err, "error locking dst buffer %s", strerror(-err));
64
65 Region::const_iterator head(reg.begin());
66 Region::const_iterator tail(reg.end());
67 if (head != tail && src_bits && dst_bits) {
Mathias Agopian076b1cc2009-04-10 14:24:30 -070068 const size_t bpp = bytesPerPixel(src->format);
69 const size_t dbpr = dst->stride * bpp;
70 const size_t sbpr = src->stride * bpp;
Mathias Agopian0926f502009-05-04 14:17:04 -070071
Mathias Agopian14998592009-07-13 18:29:59 -070072 while (head != tail) {
73 const Rect& r(*head++);
Mathias Agopian0926f502009-05-04 14:17:04 -070074 ssize_t h = r.height();
75 if (h <= 0) continue;
76 size_t size = r.width() * bpp;
77 uint8_t const * s = src_bits + (r.left + src->stride * r.top) * bpp;
78 uint8_t * d = dst_bits + (r.left + dst->stride * r.top) * bpp;
79 if (dbpr==sbpr && size==sbpr) {
80 size *= h;
81 h = 1;
Mathias Agopian076b1cc2009-04-10 14:24:30 -070082 }
Mathias Agopian0926f502009-05-04 14:17:04 -070083 do {
84 memcpy(d, s, size);
85 d += dbpr;
86 s += sbpr;
87 } while (--h > 0);
Mathias Agopian076b1cc2009-04-10 14:24:30 -070088 }
89 }
Mathias Agopian0926f502009-05-04 14:17:04 -070090
Mathias Agopian14998592009-07-13 18:29:59 -070091 if (src_bits)
92 src->unlock();
93
94 if (dst_bits)
95 dst->unlock();
96
97 return err;
Mathias Agopian076b1cc2009-04-10 14:24:30 -070098}
99
Mathias Agopian62185b72009-04-16 16:19:50 -0700100// ============================================================================
101// SurfaceControl
102// ============================================================================
103
Mathias Agopian01b76682009-04-16 20:04:08 -0700104SurfaceControl::SurfaceControl(
105 const sp<SurfaceComposerClient>& client,
Mathias Agopian62185b72009-04-16 16:19:50 -0700106 const sp<ISurface>& surface,
Mathias Agopian7e27f052010-05-28 14:22:23 -0700107 const ISurfaceComposerClient::surface_data_t& data,
Mathias Agopian18d84462009-04-16 20:30:22 -0700108 uint32_t w, uint32_t h, PixelFormat format, uint32_t flags)
Mathias Agopian62185b72009-04-16 16:19:50 -0700109 : mClient(client), mSurface(surface),
110 mToken(data.token), mIdentity(data.identity),
Mathias Agopian1c97d2e2009-08-19 17:46:26 -0700111 mWidth(data.width), mHeight(data.height), mFormat(data.format),
112 mFlags(flags)
Mathias Agopian62185b72009-04-16 16:19:50 -0700113{
114}
Mathias Agopian18d84462009-04-16 20:30:22 -0700115
Mathias Agopian62185b72009-04-16 16:19:50 -0700116SurfaceControl::~SurfaceControl()
117{
118 destroy();
119}
120
121void SurfaceControl::destroy()
122{
Mathias Agopian18d84462009-04-16 20:30:22 -0700123 if (isValid()) {
Mathias Agopian62185b72009-04-16 16:19:50 -0700124 mClient->destroySurface(mToken);
125 }
126
127 // clear all references and trigger an IPC now, to make sure things
128 // happen without delay, since these resources are quite heavy.
129 mClient.clear();
130 mSurface.clear();
131 IPCThreadState::self()->flushCommands();
132}
133
134void SurfaceControl::clear()
135{
136 // here, the window manager tells us explicitly that we should destroy
137 // the surface's resource. Soon after this call, it will also release
138 // its last reference (which will call the dtor); however, it is possible
139 // that a client living in the same process still holds references which
140 // would delay the call to the dtor -- that is why we need this explicit
141 // "clear()" call.
142 destroy();
143}
144
Mathias Agopian62185b72009-04-16 16:19:50 -0700145bool SurfaceControl::isSameSurface(
146 const sp<SurfaceControl>& lhs, const sp<SurfaceControl>& rhs)
147{
148 if (lhs == 0 || rhs == 0)
149 return false;
150 return lhs->mSurface->asBinder() == rhs->mSurface->asBinder();
151}
152
Mathias Agopian01b76682009-04-16 20:04:08 -0700153status_t SurfaceControl::setLayer(int32_t layer) {
Mathias Agopian963abad2009-11-13 15:26:29 -0800154 status_t err = validate();
Mathias Agopian01b76682009-04-16 20:04:08 -0700155 if (err < 0) return err;
Mathias Agopian631f3582010-05-25 17:51:34 -0700156 const sp<SurfaceComposerClient>& client(mClient);
Mathias Agopian01b76682009-04-16 20:04:08 -0700157 return client->setLayer(mToken, layer);
158}
159status_t SurfaceControl::setPosition(int32_t x, int32_t y) {
Mathias Agopian963abad2009-11-13 15:26:29 -0800160 status_t err = validate();
Mathias Agopian01b76682009-04-16 20:04:08 -0700161 if (err < 0) return err;
Mathias Agopian631f3582010-05-25 17:51:34 -0700162 const sp<SurfaceComposerClient>& client(mClient);
Mathias Agopian01b76682009-04-16 20:04:08 -0700163 return client->setPosition(mToken, x, y);
164}
165status_t SurfaceControl::setSize(uint32_t w, uint32_t h) {
Mathias Agopian963abad2009-11-13 15:26:29 -0800166 status_t err = validate();
Mathias Agopian01b76682009-04-16 20:04:08 -0700167 if (err < 0) return err;
Mathias Agopian631f3582010-05-25 17:51:34 -0700168 const sp<SurfaceComposerClient>& client(mClient);
Mathias Agopian01b76682009-04-16 20:04:08 -0700169 return client->setSize(mToken, w, h);
170}
171status_t SurfaceControl::hide() {
Mathias Agopian963abad2009-11-13 15:26:29 -0800172 status_t err = validate();
Mathias Agopian01b76682009-04-16 20:04:08 -0700173 if (err < 0) return err;
Mathias Agopian631f3582010-05-25 17:51:34 -0700174 const sp<SurfaceComposerClient>& client(mClient);
Mathias Agopian01b76682009-04-16 20:04:08 -0700175 return client->hide(mToken);
176}
177status_t SurfaceControl::show(int32_t layer) {
Mathias Agopian963abad2009-11-13 15:26:29 -0800178 status_t err = validate();
Mathias Agopian01b76682009-04-16 20:04:08 -0700179 if (err < 0) return err;
Mathias Agopian631f3582010-05-25 17:51:34 -0700180 const sp<SurfaceComposerClient>& client(mClient);
Mathias Agopian01b76682009-04-16 20:04:08 -0700181 return client->show(mToken, layer);
182}
183status_t SurfaceControl::freeze() {
Mathias Agopian963abad2009-11-13 15:26:29 -0800184 status_t err = validate();
Mathias Agopian01b76682009-04-16 20:04:08 -0700185 if (err < 0) return err;
Mathias Agopian631f3582010-05-25 17:51:34 -0700186 const sp<SurfaceComposerClient>& client(mClient);
Mathias Agopian01b76682009-04-16 20:04:08 -0700187 return client->freeze(mToken);
188}
189status_t SurfaceControl::unfreeze() {
Mathias Agopian963abad2009-11-13 15:26:29 -0800190 status_t err = validate();
Mathias Agopian01b76682009-04-16 20:04:08 -0700191 if (err < 0) return err;
Mathias Agopian631f3582010-05-25 17:51:34 -0700192 const sp<SurfaceComposerClient>& client(mClient);
Mathias Agopian01b76682009-04-16 20:04:08 -0700193 return client->unfreeze(mToken);
194}
195status_t SurfaceControl::setFlags(uint32_t flags, uint32_t mask) {
Mathias Agopian963abad2009-11-13 15:26:29 -0800196 status_t err = validate();
Mathias Agopian01b76682009-04-16 20:04:08 -0700197 if (err < 0) return err;
Mathias Agopian631f3582010-05-25 17:51:34 -0700198 const sp<SurfaceComposerClient>& client(mClient);
Mathias Agopian01b76682009-04-16 20:04:08 -0700199 return client->setFlags(mToken, flags, mask);
200}
201status_t SurfaceControl::setTransparentRegionHint(const Region& transparent) {
Mathias Agopian963abad2009-11-13 15:26:29 -0800202 status_t err = validate();
Mathias Agopian01b76682009-04-16 20:04:08 -0700203 if (err < 0) return err;
Mathias Agopian631f3582010-05-25 17:51:34 -0700204 const sp<SurfaceComposerClient>& client(mClient);
Mathias Agopian01b76682009-04-16 20:04:08 -0700205 return client->setTransparentRegionHint(mToken, transparent);
206}
207status_t SurfaceControl::setAlpha(float alpha) {
Mathias Agopian963abad2009-11-13 15:26:29 -0800208 status_t err = validate();
Mathias Agopian01b76682009-04-16 20:04:08 -0700209 if (err < 0) return err;
Mathias Agopian631f3582010-05-25 17:51:34 -0700210 const sp<SurfaceComposerClient>& client(mClient);
Mathias Agopian01b76682009-04-16 20:04:08 -0700211 return client->setAlpha(mToken, alpha);
212}
213status_t SurfaceControl::setMatrix(float dsdx, float dtdx, float dsdy, float dtdy) {
Mathias Agopian963abad2009-11-13 15:26:29 -0800214 status_t err = validate();
Mathias Agopian01b76682009-04-16 20:04:08 -0700215 if (err < 0) return err;
Mathias Agopian631f3582010-05-25 17:51:34 -0700216 const sp<SurfaceComposerClient>& client(mClient);
Mathias Agopian01b76682009-04-16 20:04:08 -0700217 return client->setMatrix(mToken, dsdx, dtdx, dsdy, dtdy);
218}
219status_t SurfaceControl::setFreezeTint(uint32_t tint) {
Mathias Agopian963abad2009-11-13 15:26:29 -0800220 status_t err = validate();
Mathias Agopian01b76682009-04-16 20:04:08 -0700221 if (err < 0) return err;
Mathias Agopian631f3582010-05-25 17:51:34 -0700222 const sp<SurfaceComposerClient>& client(mClient);
Mathias Agopian01b76682009-04-16 20:04:08 -0700223 return client->setFreezeTint(mToken, tint);
224}
Mathias Agopian62185b72009-04-16 16:19:50 -0700225
Mathias Agopian963abad2009-11-13 15:26:29 -0800226status_t SurfaceControl::validate() const
Mathias Agopian62185b72009-04-16 16:19:50 -0700227{
228 if (mToken<0 || mClient==0) {
229 LOGE("invalid token (%d, identity=%u) or client (%p)",
230 mToken, mIdentity, mClient.get());
231 return NO_INIT;
232 }
Mathias Agopian62185b72009-04-16 16:19:50 -0700233 return NO_ERROR;
234}
235
Mathias Agopian01b76682009-04-16 20:04:08 -0700236status_t SurfaceControl::writeSurfaceToParcel(
237 const sp<SurfaceControl>& control, Parcel* parcel)
238{
Mathias Agopian579b3f82010-06-08 19:54:15 -0700239 sp<ISurface> sur;
Mathias Agopian01b76682009-04-16 20:04:08 -0700240 uint32_t identity = 0;
Mathias Agopiancb6b9042009-07-30 18:14:56 -0700241 uint32_t width = 0;
242 uint32_t height = 0;
Mathias Agopian579b3f82010-06-08 19:54:15 -0700243 uint32_t format = 0;
244 uint32_t flags = 0;
Mathias Agopian01b76682009-04-16 20:04:08 -0700245 if (SurfaceControl::isValid(control)) {
Mathias Agopian01b76682009-04-16 20:04:08 -0700246 sur = control->mSurface;
Mathias Agopian579b3f82010-06-08 19:54:15 -0700247 identity = control->mIdentity;
Mathias Agopiancb6b9042009-07-30 18:14:56 -0700248 width = control->mWidth;
249 height = control->mHeight;
Mathias Agopian01b76682009-04-16 20:04:08 -0700250 format = control->mFormat;
251 flags = control->mFlags;
252 }
Mathias Agopianb7e930d2010-06-01 15:12:58 -0700253 parcel->writeStrongBinder(sur!=0 ? sur->asBinder() : NULL);
Mathias Agopian01b76682009-04-16 20:04:08 -0700254 parcel->writeInt32(identity);
Mathias Agopiancb6b9042009-07-30 18:14:56 -0700255 parcel->writeInt32(width);
256 parcel->writeInt32(height);
Mathias Agopian01b76682009-04-16 20:04:08 -0700257 parcel->writeInt32(format);
258 parcel->writeInt32(flags);
259 return NO_ERROR;
260}
261
262sp<Surface> SurfaceControl::getSurface() const
263{
264 Mutex::Autolock _l(mLock);
265 if (mSurfaceData == 0) {
266 mSurfaceData = new Surface(const_cast<SurfaceControl*>(this));
267 }
268 return mSurfaceData;
269}
270
Mathias Agopian076b1cc2009-04-10 14:24:30 -0700271// ============================================================================
272// Surface
273// ============================================================================
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800274
Mathias Agopianb7e930d2010-06-01 15:12:58 -0700275class SurfaceClient : public Singleton<SurfaceClient>
276{
277 // all these attributes are constants
278 sp<ISurfaceComposer> mComposerService;
279 sp<ISurfaceComposerClient> mClient;
280 status_t mStatus;
281 SharedClient* mControl;
282 sp<IMemoryHeap> mControlMemory;
283
284 SurfaceClient()
285 : Singleton<SurfaceClient>(), mStatus(NO_INIT)
286 {
287 sp<ISurfaceComposer> sf(ComposerService::getComposerService());
288 mComposerService = sf;
289 mClient = sf->createClientConnection();
290 if (mClient != NULL) {
291 mControlMemory = mClient->getControlBlock();
292 if (mControlMemory != NULL) {
293 mControl = static_cast<SharedClient *>(
294 mControlMemory->getBase());
295 if (mControl) {
296 mStatus = NO_ERROR;
297 }
298 }
299 }
300 }
301 friend class Singleton<SurfaceClient>;
302public:
303 status_t initCheck() const {
304 return mStatus;
305 }
306 SharedClient* getSharedClient() const {
307 return mControl;
308 }
309 ssize_t getTokenForSurface(const sp<ISurface>& sur) const {
310 // TODO: we could cache a few tokens here to avoid an IPC
311 return mClient->getTokenForSurface(sur);
312 }
313 void signalServer() const {
314 mComposerService->signal();
315 }
316};
317
318ANDROID_SINGLETON_STATIC_INSTANCE(SurfaceClient);
319
320// ---------------------------------------------------------------------------
321
Mathias Agopian01b76682009-04-16 20:04:08 -0700322Surface::Surface(const sp<SurfaceControl>& surface)
Mathias Agopianb7e930d2010-06-01 15:12:58 -0700323 : mBufferMapper(GraphicBufferMapper::get()),
324 mClient(SurfaceClient::getInstance()),
325 mSharedBufferClient(NULL),
Mathias Agopian631f3582010-05-25 17:51:34 -0700326 mInitCheck(NO_INIT),
Mathias Agopianb7e930d2010-06-01 15:12:58 -0700327 mSurface(surface->mSurface),
328 mIdentity(surface->mIdentity),
329 mFormat(surface->mFormat), mFlags(surface->mFlags),
Mathias Agopianba5972f2009-08-14 18:52:17 -0700330 mWidth(surface->mWidth), mHeight(surface->mHeight)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800331{
Mathias Agopian01b76682009-04-16 20:04:08 -0700332 init();
333}
Mathias Agopian62185b72009-04-16 16:19:50 -0700334
Mathias Agopiana0c30e92010-06-04 18:26:32 -0700335Surface::Surface(const Parcel& parcel, const sp<IBinder>& ref)
Mathias Agopianb7e930d2010-06-01 15:12:58 -0700336 : mBufferMapper(GraphicBufferMapper::get()),
337 mClient(SurfaceClient::getInstance()),
338 mSharedBufferClient(NULL),
339 mInitCheck(NO_INIT)
Mathias Agopian01b76682009-04-16 20:04:08 -0700340{
Mathias Agopiana0c30e92010-06-04 18:26:32 -0700341 mSurface = interface_cast<ISurface>(ref);
Mathias Agopian01b76682009-04-16 20:04:08 -0700342 mIdentity = parcel.readInt32();
Mathias Agopiancb6b9042009-07-30 18:14:56 -0700343 mWidth = parcel.readInt32();
344 mHeight = parcel.readInt32();
Mathias Agopian01b76682009-04-16 20:04:08 -0700345 mFormat = parcel.readInt32();
346 mFlags = parcel.readInt32();
Mathias Agopian01b76682009-04-16 20:04:08 -0700347 init();
348}
349
Mathias Agopian579b3f82010-06-08 19:54:15 -0700350status_t Surface::writeToParcel(
351 const sp<Surface>& surface, Parcel* parcel)
352{
353 sp<ISurface> sur;
354 uint32_t identity = 0;
355 uint32_t width = 0;
356 uint32_t height = 0;
357 uint32_t format = 0;
358 uint32_t flags = 0;
359 if (Surface::isValid(surface)) {
360 sur = surface->mSurface;
361 identity = surface->mIdentity;
362 width = surface->mWidth;
363 height = surface->mHeight;
364 format = surface->mFormat;
365 flags = surface->mFlags;
366 }
367 parcel->writeStrongBinder(sur!=0 ? sur->asBinder() : NULL);
368 parcel->writeInt32(identity);
369 parcel->writeInt32(width);
370 parcel->writeInt32(height);
371 parcel->writeInt32(format);
372 parcel->writeInt32(flags);
373 return NO_ERROR;
374
375}
376
Jamie Gennisaca4e222010-07-15 17:29:15 -0700377
378Mutex Surface::sCachedSurfacesLock;
379DefaultKeyedVector<wp<IBinder>, wp<Surface> > Surface::sCachedSurfaces(wp<Surface>(0));
380
381sp<Surface> Surface::readFromParcel(const Parcel& data) {
382 Mutex::Autolock _l(sCachedSurfacesLock);
Mathias Agopiana0c30e92010-06-04 18:26:32 -0700383 sp<IBinder> binder(data.readStrongBinder());
Jamie Gennisaca4e222010-07-15 17:29:15 -0700384 sp<Surface> surface = sCachedSurfaces.valueFor(binder).promote();
385 if (surface == 0) {
386 surface = new Surface(data, binder);
387 sCachedSurfaces.add(binder, surface);
Mathias Agopiana0c30e92010-06-04 18:26:32 -0700388 }
Jamie Gennisaca4e222010-07-15 17:29:15 -0700389 if (surface->mSurface == 0) {
390 surface = 0;
391 }
392 cleanCachedSurfaces();
393 return surface;
394}
395
396// Remove the stale entries from the surface cache. This should only be called
397// with sCachedSurfacesLock held.
398void Surface::cleanCachedSurfaces() {
399 for (int i = sCachedSurfaces.size()-1; i >= 0; --i) {
400 wp<Surface> s(sCachedSurfaces.valueAt(i));
401 if (s == 0 || s.promote() == 0) {
402 sCachedSurfaces.removeItemsAt(i);
403 }
404 }
Mathias Agopiana0c30e92010-06-04 18:26:32 -0700405}
406
Mathias Agopian01b76682009-04-16 20:04:08 -0700407void Surface::init()
408{
Dianne Hackborn4b5e91e2010-06-30 13:56:17 -0700409 ANativeWindow::setSwapInterval = setSwapInterval;
410 ANativeWindow::dequeueBuffer = dequeueBuffer;
411 ANativeWindow::lockBuffer = lockBuffer;
412 ANativeWindow::queueBuffer = queueBuffer;
413 ANativeWindow::query = query;
414 ANativeWindow::perform = perform;
Mathias Agopian631f3582010-05-25 17:51:34 -0700415
Mathias Agopian076b1cc2009-04-10 14:24:30 -0700416 DisplayInfo dinfo;
417 SurfaceComposerClient::getDisplayInfo(0, &dinfo);
Dianne Hackborn4b5e91e2010-06-30 13:56:17 -0700418 const_cast<float&>(ANativeWindow::xdpi) = dinfo.xdpi;
419 const_cast<float&>(ANativeWindow::ydpi) = dinfo.ydpi;
Mathias Agopian076b1cc2009-04-10 14:24:30 -0700420 // FIXME: set real values here
Dianne Hackborn4b5e91e2010-06-30 13:56:17 -0700421 const_cast<int&>(ANativeWindow::minSwapInterval) = 1;
422 const_cast<int&>(ANativeWindow::maxSwapInterval) = 1;
423 const_cast<uint32_t&>(ANativeWindow::flags) = 0;
Mathias Agopian631f3582010-05-25 17:51:34 -0700424
Mathias Agopian55fa2512010-03-11 15:06:54 -0800425 mConnected = 0;
Mathias Agopian631f3582010-05-25 17:51:34 -0700426 mSwapRectangle.makeInvalid();
Mathias Agopiana138f892010-05-21 17:24:35 -0700427 // two buffers by default
428 mBuffers.setCapacity(2);
429 mBuffers.insertAt(0, 2);
Mathias Agopian631f3582010-05-25 17:51:34 -0700430
Mathias Agopianb7e930d2010-06-01 15:12:58 -0700431 if (mSurface != 0 && mClient.initCheck() == NO_ERROR) {
Mathias Agopian579b3f82010-06-08 19:54:15 -0700432 int32_t token = mClient.getTokenForSurface(mSurface);
433 if (token >= 0) {
Mathias Agopianb7e930d2010-06-01 15:12:58 -0700434 mSharedBufferClient = new SharedBufferClient(
Mathias Agopian579b3f82010-06-08 19:54:15 -0700435 mClient.getSharedClient(), token, 2, mIdentity);
436 mInitCheck = mClient.getSharedClient()->validate(token);
Mathias Agopianb7e930d2010-06-01 15:12:58 -0700437 }
Mathias Agopian631f3582010-05-25 17:51:34 -0700438 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800439}
440
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800441Surface::~Surface()
442{
Mathias Agopian40b7f6e2009-04-14 18:21:47 -0700443 // this is a client-side operation, the surface is destroyed, unmap
444 // its buffers in this process.
Mathias Agopiana138f892010-05-21 17:24:35 -0700445 size_t size = mBuffers.size();
446 for (size_t i=0 ; i<size ; i++) {
Mathias Agopian50517542009-08-19 17:10:18 -0700447 if (mBuffers[i] != 0 && mBuffers[i]->handle != 0) {
Mathias Agopian21c59d02009-05-05 00:59:23 -0700448 getBufferMapper().unregisterBuffer(mBuffers[i]->handle);
Mathias Agopian076b1cc2009-04-10 14:24:30 -0700449 }
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800450 }
Mathias Agopian40b7f6e2009-04-14 18:21:47 -0700451
Mathias Agopian40b7f6e2009-04-14 18:21:47 -0700452 // clear all references and trigger an IPC now, to make sure things
453 // happen without delay, since these resources are quite heavy.
Mathias Agopiana138f892010-05-21 17:24:35 -0700454 mBuffers.clear();
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800455 mSurface.clear();
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700456 delete mSharedBufferClient;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800457 IPCThreadState::self()->flushCommands();
458}
459
Mathias Agopian631f3582010-05-25 17:51:34 -0700460bool Surface::isValid() {
461 return mInitCheck == NO_ERROR;
462}
463
464status_t Surface::validate() const
465{
466 // check that we initialized ourself properly
467 if (mInitCheck != NO_ERROR) {
Mathias Agopian579b3f82010-06-08 19:54:15 -0700468 LOGE("invalid token (identity=%u)", mIdentity);
Mathias Agopian631f3582010-05-25 17:51:34 -0700469 return mInitCheck;
470 }
471
472 // verify the identity of this surface
Mathias Agopian7e27f052010-05-28 14:22:23 -0700473 uint32_t identity = mSharedBufferClient->getIdentity();
Mathias Agopian631f3582010-05-25 17:51:34 -0700474
475 // this is a bit of a (temporary) special case, identity==0 means that
476 // no operation are allowed from the client (eg: dequeue/queue), this
477 // is used with PUSH_BUFFER surfaces for instance
478 if (identity == 0) {
479 LOGE("[Surface] invalid operation (identity=%u)", mIdentity);
480 return INVALID_OPERATION;
481 }
482
483 if (mIdentity != identity) {
Mathias Agopian579b3f82010-06-08 19:54:15 -0700484 LOGE("[Surface] using an invalid surface, "
Mathias Agopian631f3582010-05-25 17:51:34 -0700485 "identity=%u should be %d",
Mathias Agopian579b3f82010-06-08 19:54:15 -0700486 mIdentity, identity);
Mathias Agopian631f3582010-05-25 17:51:34 -0700487 return NO_INIT;
488 }
489
490 // check the surface didn't become invalid
Mathias Agopian7e27f052010-05-28 14:22:23 -0700491 status_t err = mSharedBufferClient->getStatus();
Mathias Agopian076b1cc2009-04-10 14:24:30 -0700492 if (err != NO_ERROR) {
Mathias Agopian579b3f82010-06-08 19:54:15 -0700493 LOGE("surface (identity=%u) is invalid, err=%d (%s)",
494 mIdentity, err, strerror(-err));
Mathias Agopian076b1cc2009-04-10 14:24:30 -0700495 return err;
496 }
Mathias Agopian631f3582010-05-25 17:51:34 -0700497
Mathias Agopian076b1cc2009-04-10 14:24:30 -0700498 return NO_ERROR;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800499}
500
Mathias Agopian631f3582010-05-25 17:51:34 -0700501sp<ISurface> Surface::getISurface() const {
502 return mSurface;
503}
504
Mathias Agopian076b1cc2009-04-10 14:24:30 -0700505// ----------------------------------------------------------------------------
506
Dianne Hackborn4b5e91e2010-06-30 13:56:17 -0700507int Surface::setSwapInterval(ANativeWindow* window, int interval) {
Mathias Agopian076b1cc2009-04-10 14:24:30 -0700508 return 0;
509}
510
Dianne Hackborn4b5e91e2010-06-30 13:56:17 -0700511int Surface::dequeueBuffer(ANativeWindow* window,
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700512 android_native_buffer_t** buffer) {
Mathias Agopian076b1cc2009-04-10 14:24:30 -0700513 Surface* self = getSelf(window);
514 return self->dequeueBuffer(buffer);
515}
516
Dianne Hackborn4b5e91e2010-06-30 13:56:17 -0700517int Surface::lockBuffer(ANativeWindow* window,
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700518 android_native_buffer_t* buffer) {
Mathias Agopian076b1cc2009-04-10 14:24:30 -0700519 Surface* self = getSelf(window);
520 return self->lockBuffer(buffer);
521}
522
Dianne Hackborn4b5e91e2010-06-30 13:56:17 -0700523int Surface::queueBuffer(ANativeWindow* window,
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700524 android_native_buffer_t* buffer) {
Mathias Agopian076b1cc2009-04-10 14:24:30 -0700525 Surface* self = getSelf(window);
526 return self->queueBuffer(buffer);
527}
528
Dianne Hackborn4b5e91e2010-06-30 13:56:17 -0700529int Surface::query(ANativeWindow* window,
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700530 int what, int* value) {
Mathias Agopiancb6b9042009-07-30 18:14:56 -0700531 Surface* self = getSelf(window);
532 return self->query(what, value);
533}
534
Dianne Hackborn4b5e91e2010-06-30 13:56:17 -0700535int Surface::perform(ANativeWindow* window,
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700536 int operation, ...) {
Mathias Agopian52212712009-08-11 22:34:02 -0700537 va_list args;
538 va_start(args, operation);
539 Surface* self = getSelf(window);
540 int res = self->perform(operation, args);
541 va_end(args);
542 return res;
543}
544
Mathias Agopian076b1cc2009-04-10 14:24:30 -0700545// ----------------------------------------------------------------------------
546
Mathias Agopiana138f892010-05-21 17:24:35 -0700547bool Surface::needNewBuffer(int bufIdx,
548 uint32_t *pWidth, uint32_t *pHeight,
549 uint32_t *pFormat, uint32_t *pUsage) const
550{
551 Mutex::Autolock _l(mSurfaceLock);
552
553 // Always call needNewBuffer(), since it clears the needed buffers flags
554 bool needNewBuffer = mSharedBufferClient->needNewBuffer(bufIdx);
555 bool validBuffer = mBufferInfo.validateBuffer(mBuffers[bufIdx]);
556 bool newNeewBuffer = needNewBuffer || !validBuffer;
557 if (newNeewBuffer) {
558 mBufferInfo.get(pWidth, pHeight, pFormat, pUsage);
559 }
560 return newNeewBuffer;
561}
562
Mathias Agopian076b1cc2009-04-10 14:24:30 -0700563int Surface::dequeueBuffer(android_native_buffer_t** buffer)
564{
Mathias Agopian963abad2009-11-13 15:26:29 -0800565 status_t err = validate();
Mathias Agopian076b1cc2009-04-10 14:24:30 -0700566 if (err != NO_ERROR)
567 return err;
568
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700569 ssize_t bufIdx = mSharedBufferClient->dequeue();
570 if (bufIdx < 0) {
571 LOGE("error dequeuing a buffer (%s)", strerror(bufIdx));
572 return bufIdx;
Mathias Agopian04bc12b2009-08-21 15:44:17 -0700573 }
Mathias Agopian68a6afe2009-09-15 19:10:47 -0700574
Mathias Agopiana138f892010-05-21 17:24:35 -0700575 // grow the buffer array if needed
576 const size_t size = mBuffers.size();
577 const size_t needed = bufIdx+1;
578 if (size < needed) {
579 mBuffers.insertAt(size, needed-size);
580 }
Mathias Agopian3a806952010-04-08 18:34:07 -0700581
Mathias Agopiana138f892010-05-21 17:24:35 -0700582 uint32_t w, h, format, usage;
583 if (needNewBuffer(bufIdx, &w, &h, &format, &usage)) {
584 err = getBufferLocked(bufIdx, w, h, format, usage);
585 LOGE_IF(err, "getBufferLocked(%ld, %u, %u, %u, %08x) failed (%s)",
586 bufIdx, w, h, format, usage, strerror(-err));
Mathias Agopian50517542009-08-19 17:10:18 -0700587 if (err == NO_ERROR) {
588 // reset the width/height with the what we get from the buffer
Mathias Agopiana138f892010-05-21 17:24:35 -0700589 const sp<GraphicBuffer>& backBuffer(mBuffers[bufIdx]);
Mathias Agopian50517542009-08-19 17:10:18 -0700590 mWidth = uint32_t(backBuffer->width);
591 mHeight = uint32_t(backBuffer->height);
592 }
Mathias Agopian076b1cc2009-04-10 14:24:30 -0700593 }
594
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700595 // if we still don't have a buffer here, we probably ran out of memory
Mathias Agopiana138f892010-05-21 17:24:35 -0700596 const sp<GraphicBuffer>& backBuffer(mBuffers[bufIdx]);
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700597 if (!err && backBuffer==0) {
598 err = NO_MEMORY;
599 }
600
Mathias Agopiancf81c842009-07-31 14:47:00 -0700601 if (err == NO_ERROR) {
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700602 mDirtyRegion.set(backBuffer->width, backBuffer->height);
603 *buffer = backBuffer.get();
604 } else {
605 mSharedBufferClient->undoDequeue(bufIdx);
Mathias Agopiancf81c842009-07-31 14:47:00 -0700606 }
Mathias Agopian50517542009-08-19 17:10:18 -0700607
Mathias Agopiancf81c842009-07-31 14:47:00 -0700608 return err;
Mathias Agopian076b1cc2009-04-10 14:24:30 -0700609}
610
611int Surface::lockBuffer(android_native_buffer_t* buffer)
612{
Mathias Agopian963abad2009-11-13 15:26:29 -0800613 status_t err = validate();
Mathias Agopian40b7f6e2009-04-14 18:21:47 -0700614 if (err != NO_ERROR)
615 return err;
616
Mathias Agopianb2965332010-04-27 16:41:19 -0700617 int32_t bufIdx = getBufferIndex(GraphicBuffer::getSelf(buffer));
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700618 err = mSharedBufferClient->lock(bufIdx);
619 LOGE_IF(err, "error locking buffer %d (%s)", bufIdx, strerror(-err));
620 return err;
Mathias Agopian076b1cc2009-04-10 14:24:30 -0700621}
622
623int Surface::queueBuffer(android_native_buffer_t* buffer)
624{
Mathias Agopian963abad2009-11-13 15:26:29 -0800625 status_t err = validate();
Mathias Agopian076b1cc2009-04-10 14:24:30 -0700626 if (err != NO_ERROR)
627 return err;
628
Mathias Agopian0926f502009-05-04 14:17:04 -0700629 if (mSwapRectangle.isValid()) {
630 mDirtyRegion.set(mSwapRectangle);
631 }
632
Mathias Agopianb2965332010-04-27 16:41:19 -0700633 int32_t bufIdx = getBufferIndex(GraphicBuffer::getSelf(buffer));
Mathias Agopiancc08e682010-04-15 18:48:26 -0700634 mSharedBufferClient->setCrop(bufIdx, mNextBufferCrop);
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700635 mSharedBufferClient->setDirtyRegion(bufIdx, mDirtyRegion);
636 err = mSharedBufferClient->queue(bufIdx);
637 LOGE_IF(err, "error queuing buffer %d (%s)", bufIdx, strerror(-err));
Mathias Agopian076b1cc2009-04-10 14:24:30 -0700638
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700639 if (err == NO_ERROR) {
Mathias Agopianb7e930d2010-06-01 15:12:58 -0700640 // TODO: can we avoid this IPC if we know there is one pending?
641 mClient.signalServer();
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700642 }
643 return err;
Mathias Agopian076b1cc2009-04-10 14:24:30 -0700644}
645
Mathias Agopiancb6b9042009-07-30 18:14:56 -0700646int Surface::query(int what, int* value)
647{
648 switch (what) {
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700649 case NATIVE_WINDOW_WIDTH:
650 *value = int(mWidth);
651 return NO_ERROR;
652 case NATIVE_WINDOW_HEIGHT:
653 *value = int(mHeight);
654 return NO_ERROR;
655 case NATIVE_WINDOW_FORMAT:
656 *value = int(mFormat);
657 return NO_ERROR;
Mathias Agopiancb6b9042009-07-30 18:14:56 -0700658 }
659 return BAD_VALUE;
660}
661
Mathias Agopian52212712009-08-11 22:34:02 -0700662int Surface::perform(int operation, va_list args)
663{
Mathias Agopiancc08e682010-04-15 18:48:26 -0700664 status_t err = validate();
665 if (err != NO_ERROR)
666 return err;
667
Mathias Agopian52212712009-08-11 22:34:02 -0700668 int res = NO_ERROR;
669 switch (operation) {
Mathias Agopian55fa2512010-03-11 15:06:54 -0800670 case NATIVE_WINDOW_SET_USAGE:
671 dispatch_setUsage( args );
672 break;
673 case NATIVE_WINDOW_CONNECT:
674 res = dispatch_connect( args );
675 break;
676 case NATIVE_WINDOW_DISCONNECT:
677 res = dispatch_disconnect( args );
678 break;
Mathias Agopiancc08e682010-04-15 18:48:26 -0700679 case NATIVE_WINDOW_SET_CROP:
680 res = dispatch_crop( args );
681 break;
Mathias Agopianf10d7fd2010-05-21 14:19:50 -0700682 case NATIVE_WINDOW_SET_BUFFER_COUNT:
683 res = dispatch_set_buffer_count( args );
684 break;
Mathias Agopian38ece272010-05-26 21:31:09 -0700685 case NATIVE_WINDOW_SET_BUFFERS_GEOMETRY:
686 res = dispatch_set_buffers_geometry( args );
687 break;
Mathias Agopian55fa2512010-03-11 15:06:54 -0800688 default:
689 res = NAME_NOT_FOUND;
690 break;
Mathias Agopian52212712009-08-11 22:34:02 -0700691 }
692 return res;
693}
694
Mathias Agopian55fa2512010-03-11 15:06:54 -0800695void Surface::dispatch_setUsage(va_list args) {
696 int usage = va_arg(args, int);
697 setUsage( usage );
698}
699int Surface::dispatch_connect(va_list args) {
700 int api = va_arg(args, int);
701 return connect( api );
702}
703int Surface::dispatch_disconnect(va_list args) {
704 int api = va_arg(args, int);
705 return disconnect( api );
706}
Mathias Agopiancc08e682010-04-15 18:48:26 -0700707int Surface::dispatch_crop(va_list args) {
708 android_native_rect_t const* rect = va_arg(args, android_native_rect_t*);
709 return crop( reinterpret_cast<Rect const*>(rect) );
710}
Mathias Agopianf10d7fd2010-05-21 14:19:50 -0700711int Surface::dispatch_set_buffer_count(va_list args) {
712 size_t bufferCount = va_arg(args, size_t);
713 return setBufferCount(bufferCount);
714}
Mathias Agopiana138f892010-05-21 17:24:35 -0700715int Surface::dispatch_set_buffers_geometry(va_list args) {
716 int w = va_arg(args, int);
717 int h = va_arg(args, int);
718 int f = va_arg(args, int);
719 return setBuffersGeometry(w, h, f);
720}
Mathias Agopian55fa2512010-03-11 15:06:54 -0800721
Mathias Agopianba5972f2009-08-14 18:52:17 -0700722void Surface::setUsage(uint32_t reqUsage)
723{
724 Mutex::Autolock _l(mSurfaceLock);
Mathias Agopiana138f892010-05-21 17:24:35 -0700725 mBufferInfo.set(reqUsage);
Mathias Agopianba5972f2009-08-14 18:52:17 -0700726}
727
Mathias Agopian55fa2512010-03-11 15:06:54 -0800728int Surface::connect(int api)
729{
730 Mutex::Autolock _l(mSurfaceLock);
731 int err = NO_ERROR;
732 switch (api) {
733 case NATIVE_WINDOW_API_EGL:
734 if (mConnected) {
735 err = -EINVAL;
736 } else {
737 mConnected = api;
738 }
739 break;
740 default:
741 err = -EINVAL;
742 break;
743 }
744 return err;
745}
746
747int Surface::disconnect(int api)
748{
749 Mutex::Autolock _l(mSurfaceLock);
750 int err = NO_ERROR;
751 switch (api) {
752 case NATIVE_WINDOW_API_EGL:
753 if (mConnected == api) {
754 mConnected = 0;
755 } else {
756 err = -EINVAL;
757 }
758 break;
759 default:
760 err = -EINVAL;
761 break;
762 }
763 return err;
764}
765
Mathias Agopiancc08e682010-04-15 18:48:26 -0700766int Surface::crop(Rect const* rect)
767{
768 Mutex::Autolock _l(mSurfaceLock);
769 // TODO: validate rect size
770 mNextBufferCrop = *rect;
771 return NO_ERROR;
772}
773
Mathias Agopianb5b7f262010-05-07 15:58:44 -0700774int Surface::setBufferCount(int bufferCount)
775{
776 sp<ISurface> s(mSurface);
777 if (s == 0) return NO_INIT;
778
Mathias Agopianbb641242010-05-18 17:06:55 -0700779 class SetBufferCountIPC : public SharedBufferClient::SetBufferCountCallback {
780 sp<ISurface> surface;
781 virtual status_t operator()(int bufferCount) const {
782 return surface->setBufferCount(bufferCount);
783 }
784 public:
785 SetBufferCountIPC(const sp<ISurface>& surface) : surface(surface) { }
786 } ipc(s);
Mathias Agopianb5b7f262010-05-07 15:58:44 -0700787
Mathias Agopianbb641242010-05-18 17:06:55 -0700788 status_t err = mSharedBufferClient->setBufferCount(bufferCount, ipc);
Mathias Agopianb5b7f262010-05-07 15:58:44 -0700789 LOGE_IF(err, "ISurface::setBufferCount(%d) returned %s",
790 bufferCount, strerror(-err));
Mathias Agopianb5b7f262010-05-07 15:58:44 -0700791 return err;
792}
793
Mathias Agopiana138f892010-05-21 17:24:35 -0700794int Surface::setBuffersGeometry(int w, int h, int format)
795{
796 if (w<0 || h<0 || format<0)
797 return BAD_VALUE;
798
799 if ((w && !h) || (!w && h))
800 return BAD_VALUE;
801
802 Mutex::Autolock _l(mSurfaceLock);
803 mBufferInfo.set(w, h, format);
804 return NO_ERROR;
805}
806
807// ----------------------------------------------------------------------------
808
809int Surface::getConnectedApi() const
810{
811 Mutex::Autolock _l(mSurfaceLock);
812 return mConnected;
813}
Mathias Agopian55fa2512010-03-11 15:06:54 -0800814
Mathias Agopian076b1cc2009-04-10 14:24:30 -0700815// ----------------------------------------------------------------------------
816
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800817status_t Surface::lock(SurfaceInfo* info, bool blocking) {
818 return Surface::lock(info, NULL, blocking);
819}
820
Mathias Agopian0926f502009-05-04 14:17:04 -0700821status_t Surface::lock(SurfaceInfo* other, Region* dirtyIn, bool blocking)
Mathias Agopian076b1cc2009-04-10 14:24:30 -0700822{
Mathias Agopian55fa2512010-03-11 15:06:54 -0800823 if (getConnectedApi()) {
824 LOGE("Surface::lock(%p) failed. Already connected to another API",
Dianne Hackborn4b5e91e2010-06-30 13:56:17 -0700825 (ANativeWindow*)this);
Mathias Agopian55fa2512010-03-11 15:06:54 -0800826 CallStack stack;
827 stack.update();
828 stack.dump("");
829 return INVALID_OPERATION;
830 }
831
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700832 if (mApiLock.tryLock() != NO_ERROR) {
Mathias Agopian90147262010-01-22 11:47:55 -0800833 LOGE("calling Surface::lock from different threads!");
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700834 CallStack stack;
835 stack.update();
Mathias Agopian55fa2512010-03-11 15:06:54 -0800836 stack.dump("");
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700837 return WOULD_BLOCK;
838 }
Mathias Agopian90147262010-01-22 11:47:55 -0800839
840 /* Here we're holding mApiLock */
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700841
Mathias Agopian90147262010-01-22 11:47:55 -0800842 if (mLockedBuffer != 0) {
843 LOGE("Surface::lock failed, already locked");
844 mApiLock.unlock();
845 return INVALID_OPERATION;
846 }
847
Mathias Agopian52212712009-08-11 22:34:02 -0700848 // we're intending to do software rendering from this point
Mathias Agopianba5972f2009-08-14 18:52:17 -0700849 setUsage(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN);
850
Mathias Agopianb2965332010-04-27 16:41:19 -0700851 android_native_buffer_t* out;
852 status_t err = dequeueBuffer(&out);
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700853 LOGE_IF(err, "dequeueBuffer failed (%s)", strerror(-err));
Mathias Agopian076b1cc2009-04-10 14:24:30 -0700854 if (err == NO_ERROR) {
Mathias Agopianb2965332010-04-27 16:41:19 -0700855 sp<GraphicBuffer> backBuffer(GraphicBuffer::getSelf(out));
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700856 err = lockBuffer(backBuffer.get());
857 LOGE_IF(err, "lockBuffer (idx=%d) failed (%s)",
Mathias Agopianb2965332010-04-27 16:41:19 -0700858 getBufferIndex(backBuffer), strerror(-err));
Mathias Agopian076b1cc2009-04-10 14:24:30 -0700859 if (err == NO_ERROR) {
Mathias Agopian076b1cc2009-04-10 14:24:30 -0700860 const Rect bounds(backBuffer->width, backBuffer->height);
Mathias Agopian245e4d72010-04-21 15:24:11 -0700861 const Region boundsRegion(bounds);
862 Region scratch(boundsRegion);
Mathias Agopian0926f502009-05-04 14:17:04 -0700863 Region& newDirtyRegion(dirtyIn ? *dirtyIn : scratch);
Mathias Agopian245e4d72010-04-21 15:24:11 -0700864 newDirtyRegion &= boundsRegion;
Mathias Agopian076b1cc2009-04-10 14:24:30 -0700865
Mathias Agopian245e4d72010-04-21 15:24:11 -0700866 // figure out if we can copy the frontbuffer back
Mathias Agopian3330b202009-10-05 17:07:12 -0700867 const sp<GraphicBuffer>& frontBuffer(mPostedBuffer);
Mathias Agopian245e4d72010-04-21 15:24:11 -0700868 const bool canCopyBack = (frontBuffer != 0 &&
869 backBuffer->width == frontBuffer->width &&
870 backBuffer->height == frontBuffer->height &&
871 backBuffer->format == frontBuffer->format &&
872 !(mFlags & ISurfaceComposer::eDestroyBackbuffer));
873
874 // the dirty region we report to surfaceflinger is the one
875 // given by the user (as opposed to the one *we* return to the
876 // user).
877 mDirtyRegion = newDirtyRegion;
878
879 if (canCopyBack) {
880 // copy the area that is invalid and not repainted this round
881 const Region copyback(mOldDirtyRegion.subtract(newDirtyRegion));
882 if (!copyback.isEmpty())
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700883 copyBlt(backBuffer, frontBuffer, copyback);
Mathias Agopian245e4d72010-04-21 15:24:11 -0700884 } else {
885 // if we can't copy-back anything, modify the user's dirty
886 // region to make sure they redraw the whole buffer
887 newDirtyRegion = boundsRegion;
Mathias Agopian076b1cc2009-04-10 14:24:30 -0700888 }
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700889
Mathias Agopian245e4d72010-04-21 15:24:11 -0700890 // keep track of the are of the buffer that is "clean"
891 // (ie: that will be redrawn)
Mathias Agopian0926f502009-05-04 14:17:04 -0700892 mOldDirtyRegion = newDirtyRegion;
Mathias Agopian076b1cc2009-04-10 14:24:30 -0700893
Mathias Agopiane71212b2009-05-05 00:37:46 -0700894 void* vaddr;
Mathias Agopian0926f502009-05-04 14:17:04 -0700895 status_t res = backBuffer->lock(
896 GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN,
Mathias Agopiane71212b2009-05-05 00:37:46 -0700897 newDirtyRegion.bounds(), &vaddr);
Mathias Agopian0926f502009-05-04 14:17:04 -0700898
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700899 LOGW_IF(res, "failed locking buffer (handle = %p)",
900 backBuffer->handle);
Mathias Agopian0926f502009-05-04 14:17:04 -0700901
902 mLockedBuffer = backBuffer;
903 other->w = backBuffer->width;
904 other->h = backBuffer->height;
905 other->s = backBuffer->stride;
906 other->usage = backBuffer->usage;
907 other->format = backBuffer->format;
Mathias Agopiane71212b2009-05-05 00:37:46 -0700908 other->bits = vaddr;
Mathias Agopian076b1cc2009-04-10 14:24:30 -0700909 }
910 }
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700911 mApiLock.unlock();
Mathias Agopian076b1cc2009-04-10 14:24:30 -0700912 return err;
913}
914
915status_t Surface::unlockAndPost()
916{
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700917 if (mLockedBuffer == 0) {
Mathias Agopian90147262010-01-22 11:47:55 -0800918 LOGE("Surface::unlockAndPost failed, no locked buffer");
919 return INVALID_OPERATION;
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700920 }
Mathias Agopian076b1cc2009-04-10 14:24:30 -0700921
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700922 status_t err = mLockedBuffer->unlock();
923 LOGE_IF(err, "failed unlocking buffer (%p)", mLockedBuffer->handle);
Mathias Agopian0926f502009-05-04 14:17:04 -0700924
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700925 err = queueBuffer(mLockedBuffer.get());
926 LOGE_IF(err, "queueBuffer (idx=%d) failed (%s)",
Mathias Agopianb2965332010-04-27 16:41:19 -0700927 getBufferIndex(mLockedBuffer), strerror(-err));
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700928
929 mPostedBuffer = mLockedBuffer;
Mathias Agopian076b1cc2009-04-10 14:24:30 -0700930 mLockedBuffer = 0;
931 return err;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800932}
933
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800934void Surface::setSwapRectangle(const Rect& r) {
Mathias Agopianba5972f2009-08-14 18:52:17 -0700935 Mutex::Autolock _l(mSurfaceLock);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800936 mSwapRectangle = r;
937}
938
Mathias Agopianb2965332010-04-27 16:41:19 -0700939int Surface::getBufferIndex(const sp<GraphicBuffer>& buffer) const
940{
941 return buffer->getIndex();
942}
943
Mathias Agopiana138f892010-05-21 17:24:35 -0700944status_t Surface::getBufferLocked(int index,
945 uint32_t w, uint32_t h, uint32_t format, uint32_t usage)
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800946{
Mathias Agopianba5972f2009-08-14 18:52:17 -0700947 sp<ISurface> s(mSurface);
948 if (s == 0) return NO_INIT;
949
Mathias Agopian076b1cc2009-04-10 14:24:30 -0700950 status_t err = NO_MEMORY;
Mathias Agopian50517542009-08-19 17:10:18 -0700951
952 // free the current buffer
Mathias Agopiana138f892010-05-21 17:24:35 -0700953 sp<GraphicBuffer>& currentBuffer(mBuffers.editItemAt(index));
Mathias Agopian50517542009-08-19 17:10:18 -0700954 if (currentBuffer != 0) {
955 getBufferMapper().unregisterBuffer(currentBuffer->handle);
956 currentBuffer.clear();
957 }
958
Mathias Agopiana138f892010-05-21 17:24:35 -0700959 sp<GraphicBuffer> buffer = s->requestBuffer(index, w, h, format, usage);
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700960 LOGE_IF(buffer==0,
961 "ISurface::getBuffer(%d, %08x) returned NULL",
962 index, usage);
Mathias Agopian50517542009-08-19 17:10:18 -0700963 if (buffer != 0) { // this should never happen by construction
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700964 LOGE_IF(buffer->handle == NULL,
Mathias Agopiana138f892010-05-21 17:24:35 -0700965 "Surface (identity=%d) requestBuffer(%d, %u, %u, %u, %08x) "
966 "returned a buffer with a null handle",
967 mIdentity, index, w, h, format, usage);
Mathias Agopian0b3ad462009-10-02 18:12:30 -0700968 err = mSharedBufferClient->getStatus();
969 LOGE_IF(err, "Surface (identity=%d) state = %d", mIdentity, err);
970 if (!err && buffer->handle != NULL) {
Mathias Agopian50517542009-08-19 17:10:18 -0700971 err = getBufferMapper().registerBuffer(buffer->handle);
972 LOGW_IF(err, "registerBuffer(...) failed %d (%s)",
973 err, strerror(-err));
974 if (err == NO_ERROR) {
975 currentBuffer = buffer;
Mathias Agopiancbb288b2009-09-07 16:32:45 -0700976 currentBuffer->setIndex(index);
Mathias Agopian50517542009-08-19 17:10:18 -0700977 }
Mathias Agopiand3144be2009-10-06 15:58:44 -0700978 } else {
Mathias Agopianf10d7fd2010-05-21 14:19:50 -0700979 err = err<0 ? err : status_t(NO_MEMORY);
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800980 }
981 }
Mathias Agopian076b1cc2009-04-10 14:24:30 -0700982 return err;
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800983}
984
Mathias Agopiana138f892010-05-21 17:24:35 -0700985// ----------------------------------------------------------------------------
986Surface::BufferInfo::BufferInfo()
987 : mWidth(0), mHeight(0), mFormat(0),
988 mUsage(GRALLOC_USAGE_HW_RENDER), mDirty(0)
989{
990}
991
992void Surface::BufferInfo::set(uint32_t w, uint32_t h, uint32_t format) {
993 if ((mWidth != w) || (mHeight != h) || (mFormat != format)) {
994 mWidth = w;
995 mHeight = h;
996 mFormat = format;
997 mDirty |= GEOMETRY;
998 }
999}
1000
1001void Surface::BufferInfo::set(uint32_t usage) {
1002 mUsage = usage;
1003}
1004
1005void Surface::BufferInfo::get(uint32_t *pWidth, uint32_t *pHeight,
1006 uint32_t *pFormat, uint32_t *pUsage) const {
1007 *pWidth = mWidth;
1008 *pHeight = mHeight;
1009 *pFormat = mFormat;
1010 *pUsage = mUsage;
1011}
1012
1013bool Surface::BufferInfo::validateBuffer(const sp<GraphicBuffer>& buffer) const {
1014 // make sure we AT LEAST have the usage flags we want
1015 if (mDirty || buffer==0 ||
1016 ((buffer->usage & mUsage) != mUsage)) {
1017 mDirty = 0;
1018 return false;
1019 }
1020 return true;
1021}
1022
1023// ----------------------------------------------------------------------------
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -08001024}; // namespace android